Differential D15010 Diff 40263 kmymoney/mymoney/mymoneytransactionfiltertest.cpp

Changeset View

Standalone View

kmymoney/mymoney/mymoneytransactionfiltertest.cpp

This file was added.

		1		/***************************************************************************
		2		mymoneytransactionfiltertest.cpp
		3		***************************************************************************/
		4
		5		/***************************************************************************
		6		* *
		7		* This program is free software; you can redistribute it and/or modify *
		8		* it under the terms of the GNU General Public License as published by *
		9		* the Free Software Foundation; either version 2 of the License, or *
		10		* (at your option) any later version. *
		11		* *
		12		***************************************************************************/
		13
		14		#include "mymoneytransactionfiltertest.h"
		15
		16		#include <QtTest/QtTest>
		17
		18		#include "mymoneytransactionfilter.h"
		19		#include "mymoneyfile.h"
		20		#include "mymoneyseqaccessmgr.h"
		21
		22		#undef QVERIFY
		23		#define QVERIFY(statement) \
		24		QTest::qVerify((statement), #statement, "", __FILE__, __LINE__)
		25
		26		#undef QCOMPARE
		27		#define QCOMPARE(actual, expected) \
		28		QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__)
		29
		30		using namespace std;
		31
		32		// copied from reports/reportstestcommon.cpp
		33		QString makeAccount(const QString& _name, MyMoneyAccount::accountTypeE _type, MyMoneyMoney _balance, const QDate& _open, const QString& _parent, QString _currency = "", bool _taxReport = false, bool _openingBalance = false);
		34
		35		QString makeAccount(const QString& _name, MyMoneyAccount::accountTypeE _type, MyMoneyMoney _balance, const QDate& _open, const QString& _parent, QString _currency, bool _taxReport, bool _openingBalance)
		36		{
		37		MyMoneyAccount info;
		38		MyMoneyFileTransaction ft;
		39
		40		info.setName(_name);
		41		info.setAccountType(_type);
		42		info.setOpeningDate(_open);
		43		if (!_currency.isEmpty())
		44		info.setCurrencyId(_currency);
		45		else
		46		info.setCurrencyId(MyMoneyFile::instance()->baseCurrency().id());
		47
		48		if (_taxReport)
		49		info.setValue("Tax", "Yes");
		50
		51		if (_openingBalance)
		52		info.setValue("OpeningBalanceAccount", "Yes");
		53
		54		MyMoneyAccount parent = MyMoneyFile::instance()->account(_parent);
		55		MyMoneyFile::instance()->addAccount(info, parent);
		56		// create the opening balance transaction if any
		57		if (!_balance.isZero()) {
		58		MyMoneySecurity sec = MyMoneyFile::instance()->currency(info.currencyId());
		59		MyMoneyFile::instance()->openingBalanceAccount(sec);
		60		MyMoneyFile::instance()->createOpeningBalanceTransaction(info, _balance);
		61		}
		62		ft.commit();
		63
		64		return info.id();
		65		}
		66
		67		void MyMoneyTransactionFilterTest::initTestCase()
		68		{
		69		MyMoneySeqAccessMgr *storage = new MyMoneySeqAccessMgr;
		70		MyMoneyFile *file = MyMoneyFile::instance();
		71		file->attachStorage(storage);
		72		MyMoneyFileTransaction ft;
		73
		74		file->addCurrency(MyMoneySecurity("USD", "US Dollar", "$"));
		75		file->setBaseCurrency(file->currency("USD"));
		76
		77		MyMoneyPayee payeeTest("Payee 10.2");
		78		file->addPayee(payeeTest);
		79		payeeId = payeeTest.id();
		80
		81		MyMoneyTag tag("Tag 10.2");
		82		file->addTag(tag);
		83		tagIdList << tag.id();
		84
		85		QString acAsset = MyMoneyFile::instance()->asset().id();
		86		QString acExpense = (MyMoneyFile::instance()->expense().id());
		87		QString acIncome = (MyMoneyFile::instance()->income().id());
		88		acCheckingId = makeAccount("Account 10.2", MyMoneyAccount::Checkings, MyMoneyMoney(0.0), QDate(2004, 1, 1), acAsset);
		89		acExpenseId = makeAccount("Expense", MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
		90		acIncomeId = makeAccount("Expense", MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acIncome);
		91
		92		ft.commit();
		93		}
		94
		95		void MyMoneyTransactionFilterTest::testMatchAmount()
		96		{
		97		MyMoneySplit split;
		98		split.setShares(MyMoneyMoney(123.20));
		99
		100		MyMoneyTransactionFilter filter;
		101		QVERIFY (filter.matchAmount(&split));
		102
		103		filter.setAmountFilter(MyMoneyMoney("123.0"), MyMoneyMoney("124.0"));
		104		QVERIFY (filter.matchAmount(&split));
		105		filter.setAmountFilter(MyMoneyMoney("120.0"), MyMoneyMoney("123.0"));
		106		QVERIFY (!filter.matchAmount(&split));
		107		}
		108
		109		void MyMoneyTransactionFilterTest::testMatchText()
		110		{
		111		MyMoneySplit split;
		112		MyMoneyTransactionFilter filter;
		113
		114		// no filter
		115		QVERIFY (filter.matchText(&split));
		116
		117		filter.setTextFilter(QRegExp("10.2"), false);
		118		MyMoneyTransactionFilter filterInvert;
		119		filterInvert.setTextFilter(QRegExp("10.2"), true);
		120		MyMoneyTransactionFilter filterNotFound;
		121		filterNotFound.setTextFilter(QRegExp("10.5"), false);
		122
		123		// memo
		124		split.setMemo("10.2");
		125		QVERIFY (filter.matchText(&split));
		126		QVERIFY (!filterInvert.matchText(&split));
		127		QVERIFY (!filterNotFound.matchText(&split));
		128		split.setMemo("");
		129		// payee
		130		split.setPayeeId(payeeId);
		131		QVERIFY (filter.matchText(&split));
		132		QVERIFY (!filterInvert.matchText(&split));
		133		QVERIFY (!filterNotFound.matchText(&split));
		134		split.setPayeeId("");
		135		// tag
		136		split.setTagIdList(tagIdList);
		137		QVERIFY (filter.matchText(&split));
		138		QVERIFY (!filterInvert.matchText(&split));
		139		QVERIFY (!filterNotFound.matchText(&split));
		140		split.setTagIdList(QStringList());
		141		// value
		142		split.setValue(MyMoneyMoney("10.2"));
		143		QVERIFY (filter.matchText(&split));
		144		QVERIFY (!filterInvert.matchText(&split));
		145		QVERIFY (!filterNotFound.matchText(&split));
		146		split.setValue(MyMoneyMoney("0.0"));
		147		// number
		148		split.setNumber("10.2");
		149		QVERIFY (filter.matchText(&split));
		150		QVERIFY (!filterInvert.matchText(&split));
		151		QVERIFY (!filterNotFound.matchText(&split));
		152		split.setNumber("0.0");
		153		// transaction id
		154		split.setTransactionId("10.2");
		155		QVERIFY (filter.matchText(&split));
		156		QVERIFY (!filterInvert.matchText(&split));
		157		QVERIFY (!filterNotFound.matchText(&split));
		158		split.setTransactionId("0.0");
		159		// account
		160		split.setAccountId(acCheckingId);
		161		QVERIFY (filter.matchText(&split));
		162		QVERIFY (!filterInvert.matchText(&split));
		163		QVERIFY (!filterNotFound.matchText(&split));
		164		}
		165
		166		void MyMoneyTransactionFilterTest::testMatchSplit()
		167		{
		168		qDebug() << "returns matchText() \|\| matchAmount(), which are already tested";
		169		}
		170
		171		void MyMoneyTransactionFilterTest::testMatchTransactionAll()
		172		{
		173		MyMoneySplit split;
		174		split.setAccountId(acCheckingId);
		175		split.setShares(MyMoneyMoney(123.00));
		176
		177		MyMoneySplit split2;
		178		split2.setAccountId(acExpenseId);
		179		split2.setShares(MyMoneyMoney(123.00));
		180
		181		MyMoneyTransaction transaction;
		182		transaction.setPostDate(QDate(2014, 1, 2));
		183		transaction.addSplit(split);
		184		transaction.addSplit(split2);
		185
		186		MyMoneyTransactionFilter filter;
		187		filter.setReportAllSplits(true);
		188		QVERIFY(filter.match(transaction));
		189		QCOMPARE(filter.matchingSplits().size(), 2);
		190
		191		filter.setReportAllSplits(false);
		192		QVERIFY(filter.match(transaction));
		193		// FIXME: is it correct to return no splits ?
		194		QCOMPARE(filter.matchingSplits().size(), 0);
		195		}
		196
		197		void MyMoneyTransactionFilterTest::testMatchTransactionAccount()
		198		{
		199		MyMoneySplit split;
		200		split.setAccountId(acCheckingId);
		201		split.setShares(MyMoneyMoney(123.00));
		202
		203		MyMoneySplit split2;
		204		split2.setAccountId(acExpenseId);
		205		split2.setShares(MyMoneyMoney(123.00));
		206
		207		MyMoneyTransaction transaction;
		208		transaction.setPostDate(QDate(2014, 1, 2));
		209		transaction.addSplit(split);
		210		transaction.addSplit(split2);
		211
		212		MyMoneyTransactionFilter filter;
		213		filter.addAccount(acCheckingId);
		214		filter.setReportAllSplits(true);
		215		filter.setConsiderCategory(false);
		216		QVERIFY(filter.match(transaction));
		217		QCOMPARE(filter.matchingSplits().size(), 1);
		218
		219		filter.setReportAllSplits(false);
		220		filter.setConsiderCategory(false);
		221		QVERIFY(filter.match(transaction));
		222		QCOMPARE(filter.matchingSplits().size(), 1);
		223
		224		filter.setReportAllSplits(false);
		225		filter.setConsiderCategory(true);
		226		QVERIFY(filter.match(transaction));
		227		QCOMPARE(filter.matchingSplits().size(), 1);
		228
		229		filter.setReportAllSplits(true);
		230		filter.setConsiderCategory(true);
		231		QVERIFY(filter.match(transaction));
		232		QCOMPARE(filter.matchingSplits().size(), 1);
		233		filter.clear();
		234		}
		235
		236		void MyMoneyTransactionFilterTest::testMatchTransactionCategory()
		237		{
		238		MyMoneySplit split;
		239		split.setAccountId(acCheckingId);
		240		split.setShares(MyMoneyMoney(123.00));
		241
		242		MyMoneySplit split2;
		243		split2.setAccountId(acExpenseId);
		244		split2.setShares(MyMoneyMoney(123.00));
		245
		246		MyMoneyTransaction transaction;
		247		transaction.setPostDate(QDate(2014, 1, 2));
		248		transaction.addSplit(split);
		249		transaction.addSplit(split2);
		250
		251		MyMoneyTransactionFilter filter;
		252		filter.addCategory(acExpenseId);
		253		filter.setReportAllSplits(true);
		254		filter.setConsiderCategory(true);
		255		QVERIFY(filter.match(transaction));
		256		QCOMPARE(filter.matchingSplits().size(), 2);
		257
		258		filter.setConsiderCategory(false);
		259		QVERIFY(!filter.match(transaction));
		260		}
		261
		262		void MyMoneyTransactionFilterTest::testMatchTransactionDate()
		263		{
		264		MyMoneySplit split;
		265		split.setAccountId(acCheckingId);
		266		split.setShares(MyMoneyMoney(123.00));
		267
		268		MyMoneySplit split2;
		269		split2.setAccountId(acExpenseId);
		270		split2.setShares(MyMoneyMoney(123.00));
		271
		272		MyMoneyTransaction transaction;
		273		transaction.setPostDate(QDate(2014, 1, 2));
		274		transaction.addSplit(split);
		275		transaction.addSplit(split2);
		276
		277		MyMoneyTransactionFilter filter;
		278		filter.setReportAllSplits(true);
		279		filter.setDateFilter(QDate(2014, 1, 1), QDate(2014, 1, 3));
		280		QVERIFY(filter.match(transaction));
		281		QCOMPARE(filter.matchingSplits().size(), 2);
		282
		283		filter.setReportAllSplits(false);
		284		QVERIFY(filter.match(transaction));
		285		QCOMPARE(filter.matchingSplits().size(), 1);
		286
		287		filter.setDateFilter(QDate(2014, 1, 3), QDate(2014, 1, 5));
		288		QVERIFY(!filter.match(transaction));
		289		}
		290
		291		void setupTransactionForNumber(MyMoneyTransaction &transaction, const QString &accountId)
		292		{
		293		MyMoneySplit split;
		294		split.setAccountId(accountId);
		295		split.setShares(MyMoneyMoney(123.00));
		296		split.setNumber("1");
		297		split.setMemo("1");
		298
		299		MyMoneySplit split2;
		300		split2.setAccountId(accountId);
		301		split2.setShares(MyMoneyMoney(1.00));
		302		split2.setNumber("2");
		303		split2.setMemo("2");
		304
		305		MyMoneySplit split3;
		306		split3.setAccountId(accountId);
		307		split3.setShares(MyMoneyMoney(100.00));
		308		split3.setNumber("3");
		309		split3.setMemo("3");
		310
		311		MyMoneySplit split4;
		312		split4.setAccountId(accountId);
		313		split4.setShares(MyMoneyMoney(22.00));
		314		split4.setNumber("4");
		315		split4.setMemo("4");
		316
		317		transaction.setPostDate(QDate(2014, 1, 2));
		318		transaction.addSplit(split);
		319		transaction.addSplit(split2);
		320		transaction.addSplit(split3);
		321		transaction.addSplit(split4);
		322		}
		323
		324		void runtTestMatchTransactionNumber(MyMoneyTransaction &transaction, MyMoneyTransactionFilter &filter)
		325		{
		326		// return all matching splits
		327		filter.setReportAllSplits(true);
		328
		329		filter.setNumberFilter("", "");
		330		QVERIFY(filter.match(transaction));
		331		QCOMPARE(filter.matchingSplits().size(), 4);
		332
		333		filter.setNumberFilter("1", "");
		334		QVERIFY(filter.match(transaction));
		335		QCOMPARE(filter.matchingSplits().size(), 4);
		336
		337		filter.setNumberFilter("", "4");
		338		QVERIFY(filter.match(transaction));
		339		QCOMPARE(filter.matchingSplits().size(), 4);
		340
		341		filter.setNumberFilter("1", "4");
		342		QVERIFY(filter.match(transaction));
		343		QCOMPARE(filter.matchingSplits().size(), 4);
		344
		345		filter.setNumberFilter("1", "2");
		346		QVERIFY(filter.match(transaction));
		347		QCOMPARE(filter.matchingSplits().size(), 2);
		348
		349		// do not return all matching splits
		350		filter.setReportAllSplits(false);
		351
		352		filter.setNumberFilter("1", "4");
		353		QVERIFY(filter.match(transaction));
		354		QCOMPARE(filter.matchingSplits().size(), 1);
		355
		356		filter.setNumberFilter("1", "2");
		357		QVERIFY(filter.match(transaction));
		358		QCOMPARE(filter.matchingSplits().size(), 1);
		359		}
		360
		361		void MyMoneyTransactionFilterTest::testMatchTransactionNumber()
		362		{
		363		MyMoneyTransaction transaction;
		364		setupTransactionForNumber(transaction, acCheckingId);
		365
		366		MyMoneyTransactionFilter filter;
		367		runtTestMatchTransactionNumber(transaction, filter);
		368
		369		transaction.clear();
		370		setupTransactionForNumber(transaction, acExpenseId);
		371
		372		filter.clear();
		373		runtTestMatchTransactionNumber(transaction, filter);
		374		}
		375
		376		void MyMoneyTransactionFilterTest::testMatchTransactionPayee()
		377		{
		378		MyMoneySplit split;
		379		split.setAccountId(acCheckingId);
		380		split.setShares(MyMoneyMoney(123.00));
		381		split.setPayeeId(payeeId);
		382
		383		MyMoneySplit split2;
		384		split2.setAccountId(acCheckingId);
		385		split2.setShares(MyMoneyMoney(124.00));
		386
		387		MyMoneyTransaction transaction;
		388		transaction.setPostDate(QDate(2014, 1, 2));
		389		transaction.addSplit(split);
		390		transaction.addSplit(split2);
		391
		392		MyMoneyTransactionFilter filter;
		393		filter.addPayee(payeeId);
		394
		395		filter.setReportAllSplits(true);
		396		QVERIFY(filter.match(transaction));
		397		QCOMPARE(filter.matchingSplits().size(), 1);
		398
		399		filter.setReportAllSplits(false);
		400		QVERIFY(filter.match(transaction));
		401		QCOMPARE(filter.matchingSplits().size(), 1);
		402
		403		// check no category support
		404		MyMoneySplit split3;
		405		split3.setAccountId(acExpenseId);
		406		split3.setShares(MyMoneyMoney(120.00));
		407		split3.setPayeeId(payeeId);
		408
		409		MyMoneyTransaction transaction2;
		410		transaction2.setPostDate(QDate(2014, 1, 2));
		411		transaction2.addSplit(split3);
		412
		413		filter.setReportAllSplits(true);
		414		QVERIFY(!filter.match(transaction2));
		415		QCOMPARE(filter.matchingSplits().size(), 0);
		416
		417		qDebug() << "payee on categories could not be tested";
		418		}
		419
		420		void MyMoneyTransactionFilterTest::testMatchTransactionState()
		421		{
		422		MyMoneySplit split;
		423		split.setAccountId(acCheckingId);
		424		split.setShares(MyMoneyMoney(123.00));
		425		split.setReconcileFlag(MyMoneySplit::NotReconciled);
		426
		427		MyMoneySplit split2;
		428		split2.setAccountId(acCheckingId);
		429		split2.setShares(MyMoneyMoney(1.00));
		430		split2.setReconcileFlag(MyMoneySplit::Cleared);
		431
		432		MyMoneySplit split3;
		433		split3.setAccountId(acCheckingId);
		434		split3.setShares(MyMoneyMoney(100.00));
		435		split3.setReconcileFlag(MyMoneySplit::Reconciled);
		436
		437		MyMoneySplit split4;
		438		split4.setAccountId(acCheckingId);
		439		split4.setShares(MyMoneyMoney(22.00));
		440		split4.setReconcileFlag(MyMoneySplit::Frozen);
		441
		442		MyMoneyTransaction transaction;
		443		transaction.setPostDate(QDate(2014, 1, 2));
		444		transaction.addSplit(split);
		445		transaction.addSplit(split2);
		446		transaction.addSplit(split3);
		447		transaction.addSplit(split4);
		448
		449		MyMoneyTransactionFilter filter;
		450		filter.setReportAllSplits(true);
		451		QVERIFY(filter.match(transaction));
		452		QCOMPARE(filter.matchingSplits().size(), 4);
		453
		454		// all states
		455		filter.addState(MyMoneyTransactionFilter::notReconciled);
		456		filter.addState(MyMoneyTransactionFilter::cleared);
		457		filter.addState(MyMoneyTransactionFilter::reconciled);
		458		filter.addState(MyMoneyTransactionFilter::frozen);
		459		QVERIFY(filter.match(transaction));
		460		QCOMPARE(filter.matchingSplits().size(), 4);
		461
		462		// single state
		463		filter.clear();
		464		filter.addState(MyMoneyTransactionFilter::notReconciled);
		465		QVERIFY(filter.match(transaction));
		466		QCOMPARE(filter.matchingSplits().size(), 1);
		467		filter.clear();
		468
		469		filter.addState(MyMoneyTransactionFilter::cleared);
		470		QVERIFY(filter.match(transaction));
		471		QCOMPARE(filter.matchingSplits().size(), 1);
		472		filter.clear();
		473
		474		filter.addState(MyMoneyTransactionFilter::reconciled);
		475		QVERIFY(filter.match(transaction));
		476		QCOMPARE(filter.matchingSplits().size(), 1);
		477		filter.clear();
		478
		479		filter.addState(MyMoneyTransactionFilter::frozen);
		480		QVERIFY(filter.match(transaction));
		481		QCOMPARE(filter.matchingSplits().size(), 1);
		482
		483		// check no category support
		484		MyMoneySplit split5;
		485		split5.setAccountId(acCheckingId);
		486		split5.setShares(MyMoneyMoney(22.00));
		487		split5.setReconcileFlag(MyMoneySplit::Frozen);
		488
		489		MyMoneyTransaction transaction2;
		490		transaction.setPostDate(QDate(2014, 1, 2));
		491		transaction.addSplit(split5);
		492
		493		filter.clear();
		494		filter.setReportAllSplits(true);
		495		filter.addState(MyMoneyTransactionFilter::frozen);
		496		QVERIFY(!filter.match(transaction2));
		497		QCOMPARE(filter.matchingSplits().size(), 0);
		498
		499		qDebug() << "states on categories could not be tested";
		500		}
		501
		502		void MyMoneyTransactionFilterTest::testMatchTransactionTag()
		503		{
		504		MyMoneySplit split;
		505		split.setAccountId(acCheckingId);
		506		split.setShares(MyMoneyMoney(123.00));
		507		split.setTagIdList(tagIdList);
		508
		509		MyMoneySplit split2;
		510		split2.setAccountId(acExpenseId);
		511		split2.setShares(MyMoneyMoney(123.00));
		512		split2.setTagIdList(tagIdList);
		513
		514		MyMoneySplit split3;
		515		split3.setAccountId(acCheckingId);
		516		split3.setShares(MyMoneyMoney(10.00));
		517		split3.setTagIdList(tagIdList);
		518
		519		MyMoneyTransaction transaction;
		520		transaction.setPostDate(QDate(2014, 1, 2));
		521		transaction.addSplit(split);
		522		transaction.addSplit(split2);
		523		transaction.addSplit(split3);
		524
		525		MyMoneyTransactionFilter filter;
		526		filter.addTag(tagIdList.first());
		527		filter.setReportAllSplits(true);
		528		QVERIFY(filter.match(transaction));
		529		// -1 because categories are not supported yet
		530		QCOMPARE(filter.matchingSplits().size(), 2);
		531
		532		filter.setReportAllSplits(false);
		533		QVERIFY(filter.match(transaction));
		534		QCOMPARE(filter.matchingSplits().size(), 1);
		535
		536		// check no category support
		537		MyMoneySplit split4;
		538		split4.setAccountId(acExpenseId);
		539		split4.setShares(MyMoneyMoney(123.00));
		540		split4.setTagIdList(tagIdList);
		541
		542		MyMoneyTransaction transaction2;
		543		transaction2.setPostDate(QDate(2014, 1, 2));
		544		transaction2.addSplit(split4);
		545
		546		filter.setReportAllSplits(true);
		547		QVERIFY(!filter.match(transaction2));
		548		QCOMPARE(filter.matchingSplits().size(), 0);
		549
		550		qDebug() << "tags on categories could not be tested";
		551		}
		552
		553		void MyMoneyTransactionFilterTest::testMatchTransactionTypeAllTypes()
		554		{
		555		/*
		556		alltypes
		557		- account group == MyMoneyAccount::Income \|\|
		558		- account group == MyMoneyAccount::Expense
		559		*/
		560		MyMoneySplit split;
		561		split.setAccountId(acExpenseId);
		562		split.setValue(MyMoneyMoney(123.00));
		563
		564		MyMoneySplit split2;
		565		split2.setAccountId(acIncomeId);
		566		split2.setValue(MyMoneyMoney(-123.00));
		567
		568		MyMoneyTransaction transaction;
		569		transaction.setPostDate(QDate(2014, 1, 2));
		570		transaction.addSplit(split);
		571		transaction.addSplit(split2);
		572
		573		MyMoneyTransactionFilter filter;
		574		filter.setReportAllSplits(true);
		575
		576		// all splits
		577		QVERIFY(filter.match(transaction));
		578		QCOMPARE(filter.matchingSplits().size(), 2);
		579
		580		filter.addType(MyMoneyTransactionFilter::allTypes);
		581		qDebug() << "MyMoneyTransactionFilter::allTypes could not be tested";
		582		qDebug() << "because type filter does not work with categories";
		583
		584		QVERIFY(!filter.match(transaction));
		585		QCOMPARE(filter.matchingSplits().size(), 0);
		586
		587		// ! alltypes
		588		MyMoneySplit split3;
		589		split3.setAccountId(acCheckingId);
		590		split3.setValue(MyMoneyMoney(-123.00));
		591
		592		MyMoneyTransaction transaction2;
		593		transaction2.addSplit(split3);
		594
		595		QVERIFY(!filter.match(transaction2));
		596		QCOMPARE(filter.matchingSplits().size(), 0);
		597		}
		598
		599		void MyMoneyTransactionFilterTest::testMatchTransactionTypeDeposits()
		600		{
		601		// deposits - split value is positive
		602		MyMoneySplit split;
		603		split.setAccountId(acCheckingId);
		604		split.setValue(MyMoneyMoney(123.00));
		605
		606		MyMoneyTransaction transaction;
		607		transaction.setPostDate(QDate(2014, 1, 2));
		608		transaction.addSplit(split);
		609
		610		MyMoneyTransactionFilter filter;
		611		filter.setReportAllSplits(true);
		612
		613		// all splits
		614		QVERIFY(filter.match(transaction));
		615		QCOMPARE(filter.matchingSplits().size(), 1);
		616
		617		// deposits
		618		filter.addType(MyMoneyTransactionFilter::deposits);
		619		QVERIFY(filter.match(transaction));
		620		QCOMPARE(filter.matchingSplits().size(), 1);
		621
		622		// no deposits
		623		MyMoneySplit split2;
		624		split2.setAccountId(acCheckingId);
		625		split2.setValue(MyMoneyMoney(-123.00));
		626
		627		MyMoneyTransaction transaction2;
		628		transaction2.setPostDate(QDate(2014, 1, 2));
		629		transaction2.addSplit(split2);
		630
		631		QVERIFY(!filter.match(transaction2));
		632		QCOMPARE(filter.matchingSplits().size(), 0);
		633		}
		634
		635		void MyMoneyTransactionFilterTest::testMatchTransactionTypePayments()
		636		{
		637		/*
		638		payments
		639		- account group != MyMoneyAccount::Income
		640		- account group != MyMoneyAccount::Expense
		641		- split value is not positive
		642		- number of splits != 2
		643		*/
		644		MyMoneySplit split;
		645		split.setAccountId(acCheckingId);
		646		split.setValue(MyMoneyMoney(-123.00));
		647
		648		MyMoneyTransaction transaction;
		649		transaction.setPostDate(QDate(2014, 1, 2));
		650		transaction.addSplit(split);
		651
		652		MyMoneyTransactionFilter filter;
		653		filter.setReportAllSplits(true);
		654
		655		// all splits
		656		QVERIFY(filter.match(transaction));
		657		QCOMPARE(filter.matchingSplits().size(), 1);
		658
		659		// valid payments
		660		filter.addType(MyMoneyTransactionFilter::payments);
		661		QVERIFY(filter.match(transaction));
		662		QCOMPARE(filter.matchingSplits().size(), 1);
		663
		664		// no payments
		665		// check number of splits != 2
		666		MyMoneySplit split2;
		667		split2.setAccountId(acCheckingId);
		668		split2.setValue(MyMoneyMoney(-123.00));
		669		transaction.addSplit(split2);
		670
		671		QVERIFY(!filter.match(transaction));
		672		QCOMPARE(filter.matchingSplits().size(), 0);
		673
		674		// split value is not positive
		675		MyMoneySplit split3;
		676		split3.setAccountId(acCheckingId);
		677		split3.setValue(MyMoneyMoney(123.00));
		678		transaction.addSplit(split3);
		679
		680		QVERIFY(filter.match(transaction));
		681		QCOMPARE(filter.matchingSplits().size(), 2);
		682
		683		// account group != MyMoneyAccount::Income && account group != MyMoneyAccount::Expense
		684		MyMoneySplit split4;
		685		split4.setAccountId(acExpenseId);
		686		split4.setValue(MyMoneyMoney(-124.00));
		687		transaction.addSplit(split4);
		688
		689		QVERIFY(filter.match(transaction));
		690		QCOMPARE(filter.matchingSplits().size(), 2);
		691		}
		692
		693		void MyMoneyTransactionFilterTest::testMatchTransactionTypeTransfers()
		694		{
		695		/*
		696		check transfers
		697		- number of splits == 2
		698		- account group != MyMoneyAccount::Income
		699		- account group != MyMoneyAccount::Expense
		700		*/
		701		MyMoneySplit split;
		702		split.setAccountId(acCheckingId);
		703		split.setValue(MyMoneyMoney(123.00));
		704
		705		MyMoneySplit split2;
		706		split2.setAccountId(acCheckingId);
		707		split2.setValue(MyMoneyMoney(-123.00));
		708
		709		MyMoneySplit split3;
		710		split3.setAccountId(acCheckingId);
		711		split3.setValue(MyMoneyMoney(-123.00));
		712
		713		MyMoneyTransaction transaction;
		714		transaction.setPostDate(QDate(2014, 1, 2));
		715		transaction.addSplit(split);
		716		transaction.addSplit(split2);
		717
		718		MyMoneyTransactionFilter filter;
		719		filter.setReportAllSplits(true);
		720
		721		// all splits
		722		QVERIFY(filter.match(transaction));
		723		QCOMPARE(filter.matchingSplits().size(), 2);
		724
		725		filter.addType(MyMoneyTransactionFilter::transfers);
		726
		727		QVERIFY(filter.match(transaction));
		728		QCOMPARE(filter.matchingSplits().size(), 2);
		729
		730		// transfers - invalid number of counts
		731		transaction.addSplit(split3);
		732		QVERIFY(!filter.match(transaction));
		733		QCOMPARE(filter.matchingSplits().size(), 0);
		734
		735		// transfers - invalid account
		736		MyMoneySplit split4;
		737		split4.setAccountId(acIncomeId);
		738		split4.setValue(MyMoneyMoney(-123.00));
		739
		740		MyMoneySplit split5;
		741		split5.setAccountId(acCheckingId);
		742		split5.setValue(MyMoneyMoney(123.00));
		743
		744		MyMoneyTransaction transaction2;
		745		transaction2.setPostDate(QDate(2014, 1, 2));
		746		transaction2.addSplit(split4);
		747		transaction2.addSplit(split5);
		748
		749		QVERIFY(!filter.match(transaction2));
		750		QCOMPARE(filter.matchingSplits().size(), 0);
		751		}
		752
		753		void MyMoneyTransactionFilterTest::testMatchTransactionValidity()
		754		{
		755		MyMoneySplit split;
		756		split.setAccountId(acCheckingId);
		757		split.setValue(MyMoneyMoney(123.00));
		758
		759		MyMoneySplit split2;
		760		split2.setAccountId(acExpenseId);
		761		split2.setValue(MyMoneyMoney(-123.00));
		762
		763		MyMoneyTransaction transaction;
		764		transaction.setPostDate(QDate(2014, 1, 2));
		765		transaction.addSplit(split);
		766		transaction.addSplit(split2);
		767
		768		// check valid transaction
		769		MyMoneyTransactionFilter filter;
		770		filter.addValidity(MyMoneyTransactionFilter::valid);
		771		filter.setReportAllSplits(true);
		772
		773		QVERIFY(filter.match(transaction));
		774		QCOMPARE(filter.matchingSplits().size(), 2);
		775
		776		filter.setReportAllSplits(false);
		777		QVERIFY(filter.match(transaction));
		778		QCOMPARE(filter.matchingSplits().size(), 1);
		779
		780		// check invalid transaction
		781		filter.clear();
		782		filter.addValidity(MyMoneyTransactionFilter::invalid);
		783		filter.setReportAllSplits(true);
		784
		785		QVERIFY(!filter.match(transaction));
		786		QCOMPARE(filter.matchingSplits().size(), 0);
		787
		788		// add split to make transaction invalid
		789		MyMoneySplit split3;
		790		split3.setAccountId(acExpenseId);
		791		split3.setValue(MyMoneyMoney(-10.00));
		792		transaction.addSplit(split3);
		793
		794		filter.setReportAllSplits(true);
		795		QVERIFY(filter.match(transaction));
		796		QCOMPARE(filter.matchingSplits().size(), 3);
		797
		798		filter.clear();
		799		filter.addValidity(MyMoneyTransactionFilter::valid);
		800
		801		QVERIFY(!filter.match(transaction));
		802		QCOMPARE(filter.matchingSplits().size(), 0);
		803		}
		804
		805		QTEST_MAIN(MyMoneyTransactionFilterTest)