IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'csv_import'

Browse Source
This commit is contained in:
Geert Janssens
2023-02-04 19:13:16 +01:00
parent f54927d9cf 89944ba054
commit 60209a766f
26 changed files with 1835 additions and 2039 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
libgnucash/engine/Account.cpp
View File

@@ -5706,90 +5706,71 @@ xaccAccountForEachTransaction(const Account *acc, TransactionCallback proc,
#define IMAP_FRAME "import-map"
#define IMAP_FRAME_BAYES "import-map-bayes"
/* Obtain an ImportMatchMap object from an Account or a Book */
GncImportMatchMap *
gnc_account_imap_create_imap (Account *acc)
{
GncImportMatchMap *imap;
if (!acc) return NULL;
imap = g_new0(GncImportMatchMap, 1);
/* Cache the book for easy lookups; store the account/book for
* marking dirtiness
*/
imap->acc = acc;
imap->book = gnc_account_get_book (acc);
return imap;
}
/* Look up an Account in the map */
Account*
gnc_account_imap_find_account (GncImportMatchMap *imap,
gnc_account_imap_find_account (Account *acc,
const char *category,
const char *key)
{
GValue v = G_VALUE_INIT;
GncGUID * guid = NULL;
Account *retval;
if (!imap || !key) return NULL;
if (!acc || !key) return NULL;
std::vector<std::string> path {IMAP_FRAME};
if (category)
path.push_back (category);
path.push_back (key);
qof_instance_get_path_kvp (QOF_INSTANCE (imap->acc), &v, path);
qof_instance_get_path_kvp (QOF_INSTANCE (acc), &v, path);
if (G_VALUE_HOLDS_BOXED (&v))
guid = (GncGUID*)g_value_get_boxed (&v);
retval = xaccAccountLookup (guid, imap->book);
retval = xaccAccountLookup (guid, gnc_account_get_book(acc));
g_value_unset (&v);
return retval;
}
/* Store an Account in the map */
void
gnc_account_imap_add_account (GncImportMatchMap *imap,
gnc_account_imap_add_account (Account *acc,
const char *category,
const char *key,
Account *acc)
Account *added_acc)
{
GValue v = G_VALUE_INIT;
if (!imap || !key || !acc || (strlen (key) == 0)) return;
if (!acc || !key || !added_acc || (strlen (key) == 0)) return;
std::vector<std::string> path {IMAP_FRAME};
if (category)
path.emplace_back (category);
path.emplace_back (key);
g_value_init (&v, GNC_TYPE_GUID);
g_value_set_boxed (&v, xaccAccountGetGUID (acc));
xaccAccountBeginEdit (imap->acc);
qof_instance_set_path_kvp (QOF_INSTANCE (imap->acc), &v, path);
qof_instance_set_dirty (QOF_INSTANCE (imap->acc));
xaccAccountCommitEdit (imap->acc);
g_value_set_boxed (&v, xaccAccountGetGUID (added_acc));
xaccAccountBeginEdit (acc);
qof_instance_set_path_kvp (QOF_INSTANCE (acc), &v, path);
qof_instance_set_dirty (QOF_INSTANCE (acc));
xaccAccountCommitEdit (acc);
g_value_unset (&v);
}
/* Remove a reference to an Account in the map */
void
gnc_account_imap_delete_account (GncImportMatchMap *imap,
gnc_account_imap_delete_account (Account *acc,
const char *category,
const char *key)
{
if (!imap || !key) return;
if (!acc || !key) return;
std::vector<std::string> path {IMAP_FRAME};
if (category)
path.emplace_back (category);
path.emplace_back (key);
xaccAccountBeginEdit (imap->acc);
if (qof_instance_has_path_slot (QOF_INSTANCE (imap->acc), path))
xaccAccountBeginEdit (acc);
if (qof_instance_has_path_slot (QOF_INSTANCE (acc), path))
{
qof_instance_slot_path_delete (QOF_INSTANCE (imap->acc), path);
qof_instance_slot_path_delete (QOF_INSTANCE (acc), path);
if (category)
qof_instance_slot_path_delete_if_empty (QOF_INSTANCE (imap->acc), {IMAP_FRAME, category});
qof_instance_slot_path_delete_if_empty (QOF_INSTANCE (imap->acc), {IMAP_FRAME});
qof_instance_slot_path_delete_if_empty (QOF_INSTANCE (acc), {IMAP_FRAME, category});
qof_instance_slot_path_delete_if_empty (QOF_INSTANCE (acc), {IMAP_FRAME});
}
qof_instance_set_dirty (QOF_INSTANCE (imap->acc));
xaccAccountCommitEdit (imap->acc);
qof_instance_set_dirty (QOF_INSTANCE (acc));
xaccAccountCommitEdit (acc);
}
/*--------------------------------------------------------------------------
@@ -5876,7 +5857,7 @@ highest_probability(FinalProbabilityVec const & probabilities)
}
static ProbabilityVec
get_first_pass_probabilities(GncImportMatchMap * imap, GList * tokens)
get_first_pass_probabilities(Account* acc, GList * tokens)
{
ProbabilityVec ret;
/* find the probability for each account that contains any of the tokens
@@ -5885,7 +5866,7 @@ get_first_pass_probabilities(GncImportMatchMap * imap, GList * tokens)
{
TokenAccountsInfo tokenInfo{};
auto path = std::string{IMAP_FRAME_BAYES "/"} + static_cast <char const *> (current_token->data) + "/";
qof_instance_foreach_slot_prefix (QOF_INSTANCE (imap->acc), path, &build_token_info, tokenInfo);
qof_instance_foreach_slot_prefix (QOF_INSTANCE (acc), path, &build_token_info, tokenInfo);
for (auto const & current_account_token : tokenInfo.accounts)
{
auto item = std::find_if(ret.begin(), ret.end(), [&current_account_token]
@@ -6078,12 +6059,13 @@ static constexpr double threshold = .90 * probability_factor; /* 90% */
/** Look up an Account in the map */
Account*
gnc_account_imap_find_account_bayes (GncImportMatchMap *imap, GList *tokens)
gnc_account_imap_find_account_bayes (Account *acc, GList *tokens)
{
if (!imap)
if (!acc)
return nullptr;
check_import_map_data (imap->book);
auto first_pass = get_first_pass_probabilities(imap, tokens);
auto book = gnc_account_get_book(acc);
check_import_map_data (book);
auto first_pass = get_first_pass_probabilities(acc, tokens);
if (!first_pass.size())
return nullptr;
auto final_probabilities = build_probabilities(first_pass);
@@ -6100,25 +6082,25 @@ gnc_account_imap_find_account_bayes (GncImportMatchMap *imap, GList *tokens)
} catch (gnc::guid_syntax_exception&) {
return nullptr;
}
auto account = xaccAccountLookup (reinterpret_cast<GncGUID*>(&guid), imap->book);
auto account = xaccAccountLookup (reinterpret_cast<GncGUID*>(&guid), book);
return account;
}
static void
change_imap_entry (GncImportMatchMap *imap, std::string const & path, int64_t token_count)
change_imap_entry (Account *acc, std::string const & path, int64_t token_count)
{
GValue value = G_VALUE_INIT;
PINFO("Source Account is '%s', Count is '%" G_GINT64_FORMAT "'",
xaccAccountGetName (imap->acc), token_count);
xaccAccountGetName (acc), token_count);
// check for existing guid entry
if (qof_instance_has_slot (QOF_INSTANCE(imap->acc), path.c_str ()))
if (qof_instance_has_slot (QOF_INSTANCE(acc), path.c_str ()))
{
int64_t existing_token_count = 0;
// get the existing_token_count value
qof_instance_get_path_kvp (QOF_INSTANCE (imap->acc), &value, {path});
qof_instance_get_path_kvp (QOF_INSTANCE (acc), &value, {path});
if (G_VALUE_HOLDS_INT64 (&value))
existing_token_count = g_value_get_int64 (&value);
@@ -6134,16 +6116,16 @@ change_imap_entry (GncImportMatchMap *imap, std::string const & path, int64_t to
g_value_set_int64 (&value, token_count);
// Add or Update the entry based on guid
qof_instance_set_path_kvp (QOF_INSTANCE (imap->acc), &value, {path});
gnc_features_set_used (imap->book, GNC_FEATURE_GUID_FLAT_BAYESIAN);
qof_instance_set_path_kvp (QOF_INSTANCE (acc), &value, {path});
gnc_features_set_used (gnc_account_get_book(acc), GNC_FEATURE_GUID_FLAT_BAYESIAN);
g_value_unset (&value);
}
/** Updates the imap for a given account using a list of tokens */
void
gnc_account_imap_add_account_bayes (GncImportMatchMap *imap,
gnc_account_imap_add_account_bayes (Account *acc,
GList *tokens,
Account *acc)
Account *added_acc)
{
GList *current_token;
gint64 token_count;
@@ -6151,20 +6133,20 @@ gnc_account_imap_add_account_bayes (GncImportMatchMap *imap,
char *guid_string;
ENTER(" ");
if (!imap)
if (!acc)
{
LEAVE(" ");
return;
}
check_import_map_data (imap->book);
check_import_map_data (gnc_account_get_book(acc));
g_return_if_fail (acc != NULL);
account_fullname = gnc_account_get_full_name(acc);
xaccAccountBeginEdit (imap->acc);
g_return_if_fail (added_acc != NULL);
account_fullname = gnc_account_get_full_name(added_acc);
xaccAccountBeginEdit (acc);
PINFO("account name: '%s'", account_fullname);
guid_string = guid_to_string (xaccAccountGetGUID (acc));
guid_string = guid_to_string (xaccAccountGetGUID (added_acc));
/* process each token in the list */
for (current_token = g_list_first(tokens); current_token;
@@ -6181,11 +6163,11 @@ gnc_account_imap_add_account_bayes (GncImportMatchMap *imap,
PINFO("adding token '%s'", (char*)current_token->data);
auto path = std::string {IMAP_FRAME_BAYES} + '/' + static_cast<char*>(current_token->data) + '/' + guid_string;
/* change the imap entry for the account */
change_imap_entry (imap, path, token_count);
change_imap_entry (acc, path, token_count);
}
/* free up the account fullname and guid string */
qof_instance_set_dirty (QOF_INSTANCE (imap->acc));
xaccAccountCommitEdit (imap->acc);
qof_instance_set_dirty (QOF_INSTANCE (acc));
xaccAccountCommitEdit (acc);
g_free (account_fullname);
g_free (guid_string);
LEAVE(" ");

27
libgnucash/engine/Account.h
View File

@@ -68,12 +68,6 @@ typedef struct
QofInstanceClass parent_class;
} AccountClass;
typedef struct
{
Account *acc;
QofBook *book;
} GncImportMatchMap;
/* --- type macros --- */
#define GNC_TYPE_ACCOUNT (gnc_account_get_type ())
#define GNC_ACCOUNT(o) \
@@ -914,7 +908,7 @@ typedef enum
*/
/** The gnc_account_lookup_by_name() subroutine fetches the account by
* name from the descendants of the specified account. The immediate
* children are searched first. If there is no match,, then a
* children are searched first. If there is no match, then a
* recursive search of all descendants is performed looking for a
* match.
*
@@ -1576,33 +1570,28 @@ typedef enum
int xaccAccountTreeForEachTransaction(Account *acc,
TransactionCallback proc, void *data);
/** Obtain an ImportMatchMap object from an Account or a Book
*/
GncImportMatchMap *gnc_account_imap_create_imap (Account *acc);
/* Look up an Account in the map non-Baysian
*/
Account* gnc_account_imap_find_account (GncImportMatchMap *imap, const char* category,
Account* gnc_account_imap_find_account (Account* acc, const char* category,
const char *key);
/* Store an Account in the map non Baysian
*/
void gnc_account_imap_add_account (GncImportMatchMap *imap, const char *category,
const char *key, Account *acc);
void gnc_account_imap_add_account (Account* acc, const char *category,
const char *key, Account *added_acc);
/* Remove a reference to an Account in the map non Baysian
*/
void gnc_account_imap_delete_account (GncImportMatchMap *imap, const char *category,
const char *key);
void gnc_account_imap_delete_account(Account* acc, const char* category, const char* key);
/** Look up an Account in the map using Baysian
*/
Account* gnc_account_imap_find_account_bayes (GncImportMatchMap *imap, GList* tokens);
Account* gnc_account_imap_find_account_bayes (Account* acc, GList* tokens);
/** Updates the imap for a given account using a list of tokens
*/
void gnc_account_imap_add_account_bayes (GncImportMatchMap *imap, GList* tokens,
Account *acc);
void gnc_account_imap_add_account_bayes (Account* acc, GList* tokens,
Account *added_acc);
typedef struct imap_info
{

40
libgnucash/engine/mocks/gmock-Account.cpp
View File

@@ -51,6 +51,14 @@ gnc_account_get_book(const Account *account)
return mockaccount ? mockaccount->get_book() : nullptr;
}
gnc_commodity *
xaccAccountGetCommodity(const Account *account)
{
SCOPED_TRACE("");
auto mockaccount = gnc_mockaccount(account);
return mockaccount ? mockaccount->get_commodity() : nullptr;
}
gint
xaccAccountForEachTransaction(const Account *acc, TransactionCallback proc,
void *data)
@@ -69,36 +77,30 @@ xaccAccountGetSplitList (const Account *account)
}
GncImportMatchMap *
gnc_account_imap_create_imap (Account *acc)
{
SCOPED_TRACE("");
auto mockaccount = gnc_mockaccount(acc);
return mockaccount ? mockaccount->create_imap() : nullptr;
}
Account*
gnc_account_imap_find_account (
GncImportMatchMap *imap,
Account *acc,
const char* category,
const char *key)
{
return ((GncMockImportMatchMap*)imap)->find_account(category, key);
auto mockaccount = gnc_mockaccount(acc);
return mockaccount->find_account(category, key);
}
void
gnc_account_imap_add_account (
GncImportMatchMap *imap,
Account *acc,
const char *category,
const char *key,
Account *acc)
Account *dest_acc)
{
((GncMockImportMatchMap*)imap)->add_account(category, key, acc);
auto mockaccount = gnc_mockaccount(acc);
mockaccount->add_account(category, key, dest_acc);
}
Account*
gnc_account_imap_find_account_bayes (
GncImportMatchMap *imap,
Account *acc,
GList *tokens)
{
std::vector<const char*> tokenVec;
@@ -108,14 +110,15 @@ gnc_account_imap_find_account_bayes (
tokenVec.push_back(static_cast <char const *> (token->data));
}
return ((GncMockImportMatchMap*)imap)->find_account_bayes(tokenVec);
auto mockaccount = gnc_mockaccount(acc);
return mockaccount->find_account_bayes(tokenVec);
}
void
gnc_account_imap_add_account_bayes (
GncImportMatchMap *imap,
Account *acc,
GList *tokens,
Account *acc)
Account *added_acc)
{
std::vector<const char*> tokenVec;
@@ -124,6 +127,7 @@ gnc_account_imap_add_account_bayes (
tokenVec.push_back(static_cast <char const *> (token->data));
}
((GncMockImportMatchMap*)imap)->add_account_bayes(tokenVec, acc);
auto mockaccount = gnc_mockaccount(acc);
mockaccount->add_account_bayes(tokenVec, added_acc);
}

23
libgnucash/engine/mocks/gmock-Account.h
View File

@@ -42,9 +42,13 @@ public:
MOCK_METHOD0(begin_edit, void());
MOCK_METHOD0(commit_edit, void());
MOCK_CONST_METHOD0(get_book, QofBook*());
MOCK_CONST_METHOD0(get_commodity, gnc_commodity*());
MOCK_CONST_METHOD2(for_each_transaction, gint(TransactionCallback, void*));
MOCK_CONST_METHOD0(xaccAccountGetSplitList, SplitList*());
MOCK_METHOD0(create_imap, GncImportMatchMap*());
MOCK_METHOD2(find_account, Account *(const char*, const char*));
MOCK_METHOD3(add_account, void(const char*, const char*, Account*));
MOCK_METHOD1(find_account_bayes, Account *(std::vector<const char*>&));
MOCK_METHOD2(add_account_bayes, void(std::vector<const char*>&, Account*));
protected:
/* Protect destructor to avoid MockAccount objects to be created on stack. MockAccount
@@ -53,23 +57,6 @@ protected:
};
// mock up for GncImportMatchMap
class GncMockImportMatchMap : public GncImportMatchMap
{
public:
GncMockImportMatchMap(MockAccount* account)
{
acc = account;
book = account->get_book();
};
MOCK_METHOD2(find_account, Account *(const char*, const char*));
MOCK_METHOD3(add_account, void(const char*, const char*, Account*));
MOCK_METHOD1(find_account_bayes, Account *(std::vector<const char*>&));
MOCK_METHOD2(add_account_bayes, void(std::vector<const char*>&, Account*));
};
// type conversion functions
static inline MockAccount*
gnc_mockaccount (Account *account)

8
libgnucash/engine/mocks/gmock-Transaction.cpp
View File

@@ -130,6 +130,14 @@ xaccTransGetNum (const Transaction *trans)
return mocktrans ? mocktrans->get_num() : "";
}
gnc_commodity *
xaccTransGetCurrency (const Transaction *trans)
{
SCOPED_TRACE("");
auto mocktrans = gnc_mocktransaction(trans);
return mocktrans ? mocktrans->get_currency() : nullptr;
}
gboolean
xaccTransIsOpen (const Transaction *trans)
{

1
libgnucash/engine/mocks/gmock-Transaction.h
View File

@@ -59,6 +59,7 @@ public:
MOCK_METHOD1(set_date_posted_secs_normalized, void(time64));
MOCK_CONST_METHOD0(get_description, const char *());
MOCK_METHOD1(set_description, void(const char*));
MOCK_CONST_METHOD0(get_currency, gnc_commodity *());
MOCK_CONST_METHOD0(get_notes, const char *());
MOCK_METHOD1(set_notes, void(const char*));
MOCK_CONST_METHOD0(get_imbalance_value, gnc_numeric());

100
libgnucash/engine/test/gtest-import-map.cpp
View File

@@ -81,15 +81,6 @@ protected:
Account *t_expense_account {};
};
TEST_F(ImapTest, CreateImap) {
GncImportMatchMap *imap = gnc_account_imap_create_imap (t_bank_account);
EXPECT_NE(nullptr, imap);
EXPECT_EQ(t_bank_account, imap->acc);
EXPECT_EQ(gnc_account_get_book(t_bank_account), imap->book);
g_free(imap);
}
static const char* IMAP_FRAME = "import-map";
static const char* IMAP_FRAME_BAYES = "import-map-bayes";
@@ -98,15 +89,14 @@ class ImapPlainTest : public ImapTest
protected:
void SetUp() {
ImapTest::SetUp();
t_imap = gnc_account_imap_create_imap (t_bank_account);
t_acc = t_bank_account;
}
void TearDown() {
g_free(t_imap);
ImapTest::TearDown();
}
GncImportMatchMap *t_imap {};
Account *t_acc {};
};
TEST_F(ImapPlainTest, FindAccount)
@@ -119,11 +109,11 @@ TEST_F(ImapPlainTest, FindAccount)
root->set_path({IMAP_FRAME, "pepper"}, new KvpValue{*acc1_val});
root->set_path({IMAP_FRAME, "salt"}, new KvpValue{*acc2_val});
EXPECT_EQ(t_expense_account1, gnc_account_imap_find_account(t_imap, "foo", "bar"));
EXPECT_EQ(t_expense_account2, gnc_account_imap_find_account(t_imap, "baz", "waldo"));
EXPECT_EQ(t_expense_account1, gnc_account_imap_find_account(t_imap, NULL, "pepper"));
EXPECT_EQ(t_expense_account2, gnc_account_imap_find_account(t_imap, NULL, "salt"));
EXPECT_EQ(nullptr, gnc_account_imap_find_account(t_imap, "salt", NULL));
EXPECT_EQ(t_expense_account1, gnc_account_imap_find_account(t_acc, "foo", "bar"));
EXPECT_EQ(t_expense_account2, gnc_account_imap_find_account(t_acc, "baz", "waldo"));
EXPECT_EQ(t_expense_account1, gnc_account_imap_find_account(t_acc, NULL, "pepper"));
EXPECT_EQ(t_expense_account2, gnc_account_imap_find_account(t_acc, NULL, "salt"));
EXPECT_EQ(nullptr, gnc_account_imap_find_account(t_acc, "salt", NULL));
}
TEST_F(ImapPlainTest, AddAccount)
@@ -131,23 +121,23 @@ TEST_F(ImapPlainTest, AddAccount)
// prevent the embedded beginedit/committedit from doing anything
qof_instance_increase_editlevel(QOF_INSTANCE(t_bank_account));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account(t_imap, "foo", "bar", t_expense_account1);
gnc_account_imap_add_account(t_imap, "baz", "waldo", t_expense_account2);
gnc_account_imap_add_account(t_imap, NULL, "pepper", t_expense_account1);
gnc_account_imap_add_account(t_imap, NULL, "salt", t_expense_account2);
gnc_account_imap_add_account(t_acc, "foo", "bar", t_expense_account1);
gnc_account_imap_add_account(t_acc, "baz", "waldo", t_expense_account2);
gnc_account_imap_add_account(t_acc, NULL, "pepper", t_expense_account1);
gnc_account_imap_add_account(t_acc, NULL, "salt", t_expense_account2);
EXPECT_EQ(1, qof_instance_get_editlevel(QOF_INSTANCE(t_bank_account)));
EXPECT_TRUE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account(t_imap, NULL, NULL, t_expense_account2);
gnc_account_imap_add_account(t_acc, NULL, NULL, t_expense_account2);
EXPECT_FALSE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
gnc_account_imap_add_account(t_imap, "pork", "sausage", NULL);
gnc_account_imap_add_account(t_acc, "pork", "sausage", NULL);
EXPECT_FALSE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_reset_editlevel(QOF_INSTANCE(t_bank_account));
auto root = qof_instance_get_slots(QOF_INSTANCE(t_bank_account));
auto value = root->get_slot({IMAP_FRAME, "foo", "bar"});
auto check_account = [this](KvpValue* v) {
return xaccAccountLookup(v->get<GncGUID*>(), this->t_imap->book); };
return xaccAccountLookup(v->get<GncGUID*>(), gnc_account_get_book(this->t_acc)); };
EXPECT_EQ(t_expense_account1, check_account(value));
value = root->get_slot({IMAP_FRAME, "baz", "waldo"});
EXPECT_EQ(t_expense_account2, check_account(value));
@@ -168,30 +158,30 @@ TEST_F(ImapPlainTest, DeleteAccount)
// prevent the embedded beginedit/committedit from doing anything
qof_instance_increase_editlevel(QOF_INSTANCE(t_bank_account));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account(t_imap, "foo", "bar", t_expense_account1);
gnc_account_imap_add_account(t_imap, "foo", "waldo", t_expense_account2);
gnc_account_imap_add_account(t_imap, NULL, "pepper", t_expense_account1);
gnc_account_imap_add_account(t_acc, "foo", "bar", t_expense_account1);
gnc_account_imap_add_account(t_acc, "foo", "waldo", t_expense_account2);
gnc_account_imap_add_account(t_acc, NULL, "pepper", t_expense_account1);
EXPECT_EQ(1, qof_instance_get_editlevel(QOF_INSTANCE(t_bank_account)));
EXPECT_TRUE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_delete_account(t_imap, NULL, NULL);
gnc_account_imap_delete_account(t_acc, NULL, NULL);
EXPECT_FALSE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
gnc_account_imap_delete_account(t_imap, "foo", "waldo");
gnc_account_imap_delete_account(t_acc, "foo", "waldo");
EXPECT_TRUE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
EXPECT_EQ(t_expense_account1, gnc_account_imap_find_account(t_imap, "foo", "bar"));
EXPECT_EQ(nullptr, gnc_account_imap_find_account(t_imap, "foo", "waldo"));
EXPECT_EQ(t_expense_account1, gnc_account_imap_find_account(t_acc, "foo", "bar"));
EXPECT_EQ(nullptr, gnc_account_imap_find_account(t_acc, "foo", "waldo"));
auto root = qof_instance_get_slots(QOF_INSTANCE(t_bank_account));
EXPECT_EQ(nullptr, root->get_slot(path1));
gnc_account_imap_delete_account(t_imap, "foo", "bar");
gnc_account_imap_delete_account(t_acc, "foo", "bar");
EXPECT_TRUE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
EXPECT_EQ(nullptr, root->get_slot(path2));
gnc_account_imap_delete_account(t_imap, NULL, "pepper");
gnc_account_imap_delete_account(t_acc, NULL, "pepper");
EXPECT_TRUE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
EXPECT_EQ(nullptr, root->get_slot(path3));
@@ -258,23 +248,23 @@ TEST_F(ImapBayesTest, FindAccountBayes)
root->set_path({std::string{IMAP_FRAME_BAYES} + "/" + pepper + "/" + acct1_guid}, new KvpValue{*value});
root->set_path({std::string{IMAP_FRAME_BAYES} + "/" + salt + "/" + acct2_guid}, new KvpValue{*value});
auto account = gnc_account_imap_find_account_bayes(t_imap, t_list1);
auto account = gnc_account_imap_find_account_bayes(t_acc, t_list1);
EXPECT_EQ(t_expense_account1, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list2);
account = gnc_account_imap_find_account_bayes(t_acc, t_list2);
EXPECT_EQ(t_expense_account2, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list3);
account = gnc_account_imap_find_account_bayes(t_acc, t_list3);
EXPECT_EQ(t_expense_account1, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list4);
account = gnc_account_imap_find_account_bayes(t_acc, t_list4);
EXPECT_EQ(t_expense_account2, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list5);
account = gnc_account_imap_find_account_bayes(t_acc, t_list5);
EXPECT_EQ(nullptr, account);
// only imap entries with exact token matching should be considered
root->set_path({std::string{IMAP_FRAME_BAYES} + "/" + pepper + waldo + "/" + acct2_guid}, new KvpValue{*value});
account = gnc_account_imap_find_account_bayes(t_imap, t_list3);
account = gnc_account_imap_find_account_bayes(t_acc, t_list3);
EXPECT_EQ(t_expense_account1, account);
root->set_path({std::string{IMAP_FRAME_BAYES} + "/" + pepper + "/" + waldo + "/" + acct2_guid}, new KvpValue{*value});
account = gnc_account_imap_find_account_bayes(t_imap, t_list3);
account = gnc_account_imap_find_account_bayes(t_acc, t_list3);
EXPECT_EQ(t_expense_account1, account);
}
@@ -283,14 +273,14 @@ TEST_F(ImapBayesTest, AddAccountBayes)
// prevent the embedded beginedit/committedit from doing anything
qof_instance_increase_editlevel(QOF_INSTANCE(t_bank_account));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account_bayes(t_imap, t_list1, t_expense_account1);
gnc_account_imap_add_account_bayes(t_imap, t_list2, t_expense_account2);
gnc_account_imap_add_account_bayes(t_imap, t_list3, t_expense_account1);
gnc_account_imap_add_account_bayes(t_imap, t_list4, t_expense_account2);
gnc_account_imap_add_account_bayes(t_acc, t_list1, t_expense_account1);
gnc_account_imap_add_account_bayes(t_acc, t_list2, t_expense_account2);
gnc_account_imap_add_account_bayes(t_acc, t_list3, t_expense_account1);
gnc_account_imap_add_account_bayes(t_acc, t_list4, t_expense_account2);
EXPECT_EQ(1, qof_instance_get_editlevel(QOF_INSTANCE(t_bank_account)));
EXPECT_TRUE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account_bayes(t_imap, t_list5, NULL);
gnc_account_imap_add_account_bayes(t_acc, t_list5, NULL);
EXPECT_FALSE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_reset_editlevel(QOF_INSTANCE(t_bank_account));
@@ -299,7 +289,7 @@ TEST_F(ImapBayesTest, AddAccountBayes)
auto acct2_guid = guid_to_string (xaccAccountGetGUID(t_expense_account2));
auto value = root->get_slot({std::string{IMAP_FRAME_BAYES} + "/foo/bar"});
auto check_account = [this](KvpValue* v) {
return (v->get<const char*>(), this->t_imap->book); };
return (v->get<const char*>(), gnc_account_get_book(this->t_acc)); };
value = root->get_slot({std::string{IMAP_FRAME_BAYES} + "/" + foo + "/" + acct1_guid});
EXPECT_EQ(1, value->get<int64_t>());
value = root->get_slot({std::string{IMAP_FRAME_BAYES} + "/" + bar + "/" + acct1_guid});
@@ -316,7 +306,7 @@ TEST_F(ImapBayesTest, AddAccountBayes)
EXPECT_EQ(nullptr, value);
qof_instance_increase_editlevel(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account_bayes(t_imap, t_list2, t_expense_account2);
gnc_account_imap_add_account_bayes(t_acc, t_list2, t_expense_account2);
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
qof_instance_reset_editlevel(QOF_INSTANCE(t_bank_account));
value = root->get_slot({std::string{IMAP_FRAME_BAYES} + "/" + baz + "/" + acct2_guid});
@@ -326,7 +316,7 @@ TEST_F(ImapBayesTest, AddAccountBayes)
TEST_F(ImapBayesTest, ConvertBayesData)
{
auto root = qof_instance_get_slots(QOF_INSTANCE(t_bank_account));
auto book = qof_instance_get_slots(QOF_INSTANCE(t_imap->book));
auto book = qof_instance_get_slots(QOF_INSTANCE(gnc_account_get_book(this->t_acc)));
auto acct1_guid = guid_to_string (xaccAccountGetGUID(t_expense_account1)); //Food
auto acct2_guid = guid_to_string (xaccAccountGetGUID(t_expense_account2)); //Drink
auto acct3_guid = guid_to_string (xaccAccountGetGUID(t_asset_account2)); //Asset-Bank
@@ -345,7 +335,7 @@ TEST_F(ImapBayesTest, ConvertBayesData)
/* make sure to reset the conversion has been run flag */
gnc_account_reset_convert_bayes_to_flat ();
/*Calling into the imap functions should trigger a conversion.*/
gnc_account_imap_add_account_bayes(t_imap, t_list5, t_expense_account2); //pork and sausage; account Food
gnc_account_imap_add_account_bayes(t_acc, t_list5, t_expense_account2); //pork and sausage; account Food
// convert from 'Asset-Bank' to 'Asset-Bank' guid
auto value = root->get_slot({std::string{IMAP_FRAME_BAYES} + "/severely/divided/token/" + acct3_guid});
EXPECT_EQ(10, value->get<int64_t>());
@@ -373,10 +363,10 @@ TEST_F (ImapBayesTest, import_map_with_delimiters)
{
GList * tokens {nullptr};
tokens = g_list_prepend (tokens, const_cast<char*> ("one/two/three"));
gnc_account_imap_add_account_bayes (t_imap, tokens, t_expense_account1);
gnc_account_imap_add_account_bayes (t_imap, tokens, t_expense_account1);
gnc_account_imap_add_account_bayes (t_imap, tokens, t_expense_account1);
auto account = gnc_account_imap_find_account_bayes (t_imap, tokens);
gnc_account_imap_add_account_bayes (t_acc, tokens, t_expense_account1);
gnc_account_imap_add_account_bayes (t_acc, tokens, t_expense_account1);
gnc_account_imap_add_account_bayes (t_acc, tokens, t_expense_account1);
auto account = gnc_account_imap_find_account_bayes (t_acc, tokens);
EXPECT_EQ (account, t_expense_account1);
}
@@ -384,8 +374,8 @@ TEST_F (ImapBayesTest, get_bayes_info)
{
GList * tokens {nullptr};
tokens = g_list_prepend (tokens, const_cast <char*> ("one/two/three"));
gnc_account_imap_add_account_bayes(t_imap, tokens, t_expense_account1);
auto account = gnc_account_imap_find_account_bayes (t_imap, tokens);
gnc_account_imap_add_account_bayes(t_acc, tokens, t_expense_account1);
auto account = gnc_account_imap_find_account_bayes (t_acc, tokens);
EXPECT_EQ (account, t_expense_account1);
auto infos = gnc_account_imap_get_info_bayes (t_bank_account);
EXPECT_EQ (g_list_first (infos), g_list_last (infos));