Git-Mirrors/keepassxc
1
0
Fork 0
mirror of https://github.com/keepassxreboot/keepassxc.git synced 2024-10-01 01:26:01 -04:00
Code Issues Packages Projects Releases Wiki Activity
99aafe657d
keepassxc/tests/TestGroup.cpp

1210 lines
41 KiB
C++
Raw Normal View History

Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
/*
* Copyright (C) 2010 Felix Geyer <debfx@fobos.de>
Update and fix copyright headers
2017-06-09 17:40:36 -04:00
* Copyright (C) 2017 KeePassXC Team <team@keepassxc.org>
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 or (at your option)
* version 3 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
No longer use automoc.
2010-11-21 17:06:30 -05:00
#include "TestGroup.h"
Move useful QTest template specializations to global header file Fix KDBX test linker errors on Windows
2018-01-24 07:22:20 -05:00
#include "TestGlobal.h"
Rename TestClock to MockClock and move it to the mock directory
2018-10-19 14:22:28 -04:00
#include "mock/MockClock.h"
No longer use automoc.
2010-11-21 17:06:30 -05:00
Drop Qt module name from include statements. This is a preparation to be able to build KeePassX against Qt 5.
2013-10-03 09:18:16 -04:00
#include <QSignalSpy>
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
Copy custom icons when moved to another database. Closes #9
2012-04-27 05:22:02 -04:00
#include "core/Metadata.h"
Add missing crypto initalization in tests.
2011-11-12 14:00:19 -05:00
#include "crypto/Crypto.h"
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
Move QTEST_GUILESS_MAIN statements before test cases.
2014-05-16 06:32:52 -04:00
QTEST_GUILESS_MAIN(TestGroup)
Introduce synchronize merge method * Create history-based merging that keeps older data in history instead of discarding or deleting it * Extract merge logic into the Merger class * Allows special merge behavior * Improve handling of deletion and changes on groups * Enable basic change tracking while merging * Prevent unintended timestamp changes while merging * Handle differences in timestamp precision * Introduce comparison operators to allow for more sophisticated comparisons (ignore special properties, ...) * Introduce Clock class to handle datetime across the app Merge Strategies: * Default (use inherited/fallback method) * Duplicate (duplicate conflicting nodes, apply all deletions) * KeepLocal (use local values, but apply all deletions) * KeepRemote (use remote values, but apply all deletions) * KeepNewer (merge history only) * Synchronize (merge history, newest value stays on top, apply all deletions)
2018-09-30 08:45:06 -04:00
namespace
{
Rename TestClock to MockClock and move it to the mock directory
2018-10-19 14:22:28 -04:00
MockClock* m_clock = nullptr;
Introduce synchronize merge method * Create history-based merging that keeps older data in history instead of discarding or deleting it * Extract merge logic into the Merger class * Allows special merge behavior * Improve handling of deletion and changes on groups * Enable basic change tracking while merging * Prevent unintended timestamp changes while merging * Handle differences in timestamp precision * Introduce comparison operators to allow for more sophisticated comparisons (ignore special properties, ...) * Introduce Clock class to handle datetime across the app Merge Strategies: * Default (use inherited/fallback method) * Duplicate (duplicate conflicting nodes, apply all deletions) * KeepLocal (use local values, but apply all deletions) * KeepRemote (use remote values, but apply all deletions) * KeepNewer (merge history only) * Synchronize (merge history, newest value stays on top, apply all deletions)
2018-09-30 08:45:06 -04:00
}
Move qRegisterMetaType calls into initTestCase().
2010-09-18 11:15:22 -04:00
void TestGroup::initTestCase()
{
TestGroup: Register Entry as a meta type.
2012-04-18 11:42:55 -04:00
qRegisterMetaType<Entry*>("Entry*");
Move qRegisterMetaType calls into initTestCase().
2010-09-18 11:15:22 -04:00
qRegisterMetaType<Group*>("Group*");
Do some basic self-checks when initializing the crypto backend.
2014-06-15 05:17:40 -04:00
QVERIFY(Crypto::init());
Move qRegisterMetaType calls into initTestCase().
2010-09-18 11:15:22 -04:00
}
Introduce synchronize merge method * Create history-based merging that keeps older data in history instead of discarding or deleting it * Extract merge logic into the Merger class * Allows special merge behavior * Improve handling of deletion and changes on groups * Enable basic change tracking while merging * Prevent unintended timestamp changes while merging * Handle differences in timestamp precision * Introduce comparison operators to allow for more sophisticated comparisons (ignore special properties, ...) * Introduce Clock class to handle datetime across the app Merge Strategies: * Default (use inherited/fallback method) * Duplicate (duplicate conflicting nodes, apply all deletions) * KeepLocal (use local values, but apply all deletions) * KeepRemote (use remote values, but apply all deletions) * KeepNewer (merge history only) * Synchronize (merge history, newest value stays on top, apply all deletions)
2018-09-30 08:45:06 -04:00
void TestGroup::init()
{
Q_ASSERT(m_clock == nullptr);
Rename TestClock to MockClock and move it to the mock directory
2018-10-19 14:22:28 -04:00
m_clock = new MockClock(2010, 5, 5, 10, 30, 10);
MockClock::setup(m_clock);
Introduce synchronize merge method * Create history-based merging that keeps older data in history instead of discarding or deleting it * Extract merge logic into the Merger class * Allows special merge behavior * Improve handling of deletion and changes on groups * Enable basic change tracking while merging * Prevent unintended timestamp changes while merging * Handle differences in timestamp precision * Introduce comparison operators to allow for more sophisticated comparisons (ignore special properties, ...) * Introduce Clock class to handle datetime across the app Merge Strategies: * Default (use inherited/fallback method) * Duplicate (duplicate conflicting nodes, apply all deletions) * KeepLocal (use local values, but apply all deletions) * KeepRemote (use remote values, but apply all deletions) * KeepNewer (merge history only) * Synchronize (merge history, newest value stays on top, apply all deletions)
2018-09-30 08:45:06 -04:00
}
void TestGroup::cleanup()
{
Rename TestClock to MockClock and move it to the mock directory
2018-10-19 14:22:28 -04:00
MockClock::teardown();
Introduce synchronize merge method * Create history-based merging that keeps older data in history instead of discarding or deleting it * Extract merge logic into the Merger class * Allows special merge behavior * Improve handling of deletion and changes on groups * Enable basic change tracking while merging * Prevent unintended timestamp changes while merging * Handle differences in timestamp precision * Introduce comparison operators to allow for more sophisticated comparisons (ignore special properties, ...) * Introduce Clock class to handle datetime across the app Merge Strategies: * Default (use inherited/fallback method) * Duplicate (duplicate conflicting nodes, apply all deletions) * KeepLocal (use local values, but apply all deletions) * KeepRemote (use remote values, but apply all deletions) * KeepNewer (merge history only) * Synchronize (merge history, newest value stays on top, apply all deletions)
2018-09-30 08:45:06 -04:00
m_clock = nullptr;
}
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
void TestGroup::testParenting()
{
Database* db = new Database();
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
QPointer<Group> rootGroup = db->rootGroup();
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
Group* tmpRoot = new Group();
Clean up objects in the tests.
2011-06-29 12:40:26 -04:00
QPointer<Group> g1 = new Group();
QPointer<Group> g2 = new Group();
QPointer<Group> g3 = new Group();
QPointer<Group> g4 = new Group();
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
g1->setParent(tmpRoot);
g2->setParent(tmpRoot);
g3->setParent(tmpRoot);
g4->setParent(tmpRoot);
g2->setParent(g1);
g4->setParent(g3);
g3->setParent(g1);
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
g1->setParent(db->rootGroup());
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
QVERIFY(g1->parent() == rootGroup);
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
QVERIFY(g2->parent() == g1);
QVERIFY(g3->parent() == g1);
QVERIFY(g4->parent() == g3);
Add more tests.
2010-08-14 08:26:25 -04:00
QVERIFY(g1->database() == db);
QVERIFY(g2->database() == db);
QVERIFY(g3->database() == db);
QVERIFY(g4->database() == db);
Use QCOMPARE instead of QVERIFY where possible.
2010-08-18 05:05:46 -04:00
QCOMPARE(tmpRoot->children().size(), 0);
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
QCOMPARE(rootGroup->children().size(), 1);
Use QCOMPARE instead of QVERIFY where possible.
2010-08-18 05:05:46 -04:00
QCOMPARE(g1->children().size(), 2);
QCOMPARE(g2->children().size(), 0);
QCOMPARE(g3->children().size(), 1);
QCOMPARE(g4->children().size(), 0);
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QVERIFY(rootGroup->children().at(0) == g1);
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
QVERIFY(rootGroup->children().at(0) == g1);
Add GroupModel and corresponding unit test.
2010-08-15 06:31:48 -04:00
QVERIFY(g1->children().at(0) == g2);
QVERIFY(g1->children().at(1) == g3);
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
QVERIFY(g3->children().contains(g4));
Add signal for changes in Group.
2010-08-15 09:03:47 -04:00
Extend group test.
2012-04-25 04:17:24 -04:00
Group* g5 = new Group();
Group* g6 = new Group();
g5->setParent(db->rootGroup());
g6->setParent(db->rootGroup());
QVERIFY(db->rootGroup()->children().at(1) == g5);
QVERIFY(db->rootGroup()->children().at(2) == g6);
g5->setParent(db->rootGroup());
QVERIFY(db->rootGroup()->children().at(1) == g6);
QVERIFY(db->rootGroup()->children().at(2) == g5);
Un-constify Entry* and Group* in various related signals and models/views.
2010-08-23 15:30:20 -04:00
QSignalSpy spy(db, SIGNAL(groupDataChanged(Group*)));
Add signal for changes in Group.
2010-08-15 09:03:47 -04:00
g2->setName("test");
g4->setName("test");
g3->setName("test");
g1->setName("test");
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
g3->setIcon(QUuid::createUuid());
Add signal for changes in Group.
2010-08-15 09:03:47 -04:00
g1->setIcon(2);
Use QCOMPARE instead of QVERIFY where possible.
2010-08-18 05:05:46 -04:00
QCOMPARE(spy.count(), 6);
Clean up objects in the tests.
2011-06-29 12:40:26 -04:00
delete db;
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
QVERIFY(rootGroup.isNull());
Clean up objects in the tests.
2011-06-29 12:40:26 -04:00
QVERIFY(g1.isNull());
QVERIFY(g2.isNull());
QVERIFY(g3.isNull());
QVERIFY(g4.isNull());
delete tmpRoot;
Fix parser and add unit tests.
2010-08-13 12:08:06 -04:00
}
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
void TestGroup::testSignals()
{
Database* db = new Database();
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
Database* db2 = new Database();
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
QPointer<Group> root = db->rootGroup();
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QSignalSpy spyAboutToAdd(db, SIGNAL(groupAboutToAdd(Group*, int)));
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
QSignalSpy spyAdded(db, SIGNAL(groupAdded()));
Un-constify Entry* and Group* in various related signals and models/views.
2010-08-23 15:30:20 -04:00
QSignalSpy spyAboutToRemove(db, SIGNAL(groupAboutToRemove(Group*)));
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
QSignalSpy spyRemoved(db, SIGNAL(groupRemoved()));
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QSignalSpy spyAboutToMove(db, SIGNAL(groupAboutToMove(Group*, Group*, int)));
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
QSignalSpy spyMoved(db, SIGNAL(groupMoved()));
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QSignalSpy spyAboutToAdd2(db2, SIGNAL(groupAboutToAdd(Group*, int)));
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
QSignalSpy spyAdded2(db2, SIGNAL(groupAdded()));
QSignalSpy spyAboutToRemove2(db2, SIGNAL(groupAboutToRemove(Group*)));
QSignalSpy spyRemoved2(db2, SIGNAL(groupRemoved()));
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QSignalSpy spyAboutToMove2(db2, SIGNAL(groupAboutToMove(Group*, Group*, int)));
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
QSignalSpy spyMoved2(db2, SIGNAL(groupMoved()));
Group* g1 = new Group();
Group* g2 = new Group();
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
g1->setParent(root);
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
QCOMPARE(spyAboutToAdd.count(), 1);
QCOMPARE(spyAdded.count(), 1);
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
QCOMPARE(spyAboutToRemove.count(), 0);
QCOMPARE(spyRemoved.count(), 0);
QCOMPARE(spyAboutToMove.count(), 0);
QCOMPARE(spyMoved.count(), 0);
g2->setParent(root);
QCOMPARE(spyAboutToAdd.count(), 2);
QCOMPARE(spyAdded.count(), 2);
QCOMPARE(spyAboutToRemove.count(), 0);
QCOMPARE(spyRemoved.count(), 0);
QCOMPARE(spyAboutToMove.count(), 0);
QCOMPARE(spyMoved.count(), 0);
Fix bug where index is wrong when a group is moved to the end from the same parent. This triggered the bug: group->setParent(group->parentGroup()); Then index was group->parentGroup()->children().size() instead of size()-1.
2012-04-24 18:10:06 -04:00
g2->setParent(root);
QCOMPARE(spyAboutToAdd.count(), 2);
QCOMPARE(spyAdded.count(), 2);
QCOMPARE(spyAboutToRemove.count(), 0);
QCOMPARE(spyRemoved.count(), 0);
QCOMPARE(spyAboutToMove.count(), 0);
QCOMPARE(spyMoved.count(), 0);
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
g2->setParent(root, 0);
QCOMPARE(spyAboutToAdd.count(), 2);
QCOMPARE(spyAdded.count(), 2);
QCOMPARE(spyAboutToRemove.count(), 0);
QCOMPARE(spyRemoved.count(), 0);
QCOMPARE(spyAboutToMove.count(), 1);
QCOMPARE(spyMoved.count(), 1);
g1->setParent(g2);
QCOMPARE(spyAboutToAdd.count(), 2);
QCOMPARE(spyAdded.count(), 2);
QCOMPARE(spyAboutToRemove.count(), 0);
QCOMPARE(spyRemoved.count(), 0);
QCOMPARE(spyAboutToMove.count(), 2);
QCOMPARE(spyMoved.count(), 2);
delete g1;
QCOMPARE(spyAboutToAdd.count(), 2);
QCOMPARE(spyAdded.count(), 2);
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
QCOMPARE(spyAboutToRemove.count(), 1);
QCOMPARE(spyRemoved.count(), 1);
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
QCOMPARE(spyAboutToMove.count(), 2);
QCOMPARE(spyMoved.count(), 2);
g2->setParent(db2->rootGroup());
QCOMPARE(spyAboutToAdd.count(), 2);
QCOMPARE(spyAdded.count(), 2);
QCOMPARE(spyAboutToRemove.count(), 2);
QCOMPARE(spyRemoved.count(), 2);
QCOMPARE(spyAboutToMove.count(), 2);
QCOMPARE(spyMoved.count(), 2);
QCOMPARE(spyAboutToAdd2.count(), 1);
QCOMPARE(spyAdded2.count(), 1);
QCOMPARE(spyAboutToRemove2.count(), 0);
QCOMPARE(spyRemoved2.count(), 0);
QCOMPARE(spyAboutToMove2.count(), 0);
QCOMPARE(spyMoved2.count(), 0);
Add EntryModel.
2010-08-18 10:22:48 -04:00
Extend group test.
2012-04-25 04:17:24 -04:00
Group* g3 = new Group();
Group* g4 = new Group();
g3->setParent(root);
QCOMPARE(spyAboutToAdd.count(), 3);
QCOMPARE(spyAdded.count(), 3);
QCOMPARE(spyAboutToRemove.count(), 2);
QCOMPARE(spyRemoved.count(), 2);
QCOMPARE(spyAboutToMove.count(), 2);
QCOMPARE(spyMoved.count(), 2);
g4->setParent(root);
QCOMPARE(spyAboutToAdd.count(), 4);
QCOMPARE(spyAdded.count(), 4);
QCOMPARE(spyAboutToRemove.count(), 2);
QCOMPARE(spyRemoved.count(), 2);
QCOMPARE(spyAboutToMove.count(), 2);
QCOMPARE(spyMoved.count(), 2);
g3->setParent(root);
QCOMPARE(spyAboutToAdd.count(), 4);
QCOMPARE(spyAdded.count(), 4);
QCOMPARE(spyAboutToRemove.count(), 2);
QCOMPARE(spyRemoved.count(), 2);
QCOMPARE(spyAboutToMove.count(), 3);
QCOMPARE(spyMoved.count(), 3);
Add EntryModel.
2010-08-18 10:22:48 -04:00
delete db;
Introduce Group::aboutToMove() and moved() signals. Emit them instead of remove/add when groups are moved within a database.
2012-04-23 10:57:08 -04:00
delete db2;
Clean up objects in the tests.
2011-06-29 12:40:26 -04:00
QVERIFY(root.isNull());
Add EntryModel.
2010-08-18 10:22:48 -04:00
}
void TestGroup::testEntries()
{
Group* group = new Group();
Clean up objects in the tests.
2011-06-29 12:40:26 -04:00
QPointer<Entry> entry1 = new Entry();
Add EntryModel.
2010-08-18 10:22:48 -04:00
entry1->setGroup(group);
Clean up objects in the tests.
2011-06-29 12:40:26 -04:00
QPointer<Entry> entry2 = new Entry();
Add EntryModel.
2010-08-18 10:22:48 -04:00
entry2->setGroup(group);
QCOMPARE(group->entries().size(), 2);
QVERIFY(group->entries().at(0) == entry1);
QVERIFY(group->entries().at(1) == entry2);
delete group;
Clean up objects in the tests.
2011-06-29 12:40:26 -04:00
QVERIFY(entry1.isNull());
QVERIFY(entry2.isNull());
Implement support for group tree changes in GroupModel.
2010-08-18 04:27:40 -04:00
}
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
void TestGroup::testDeleteSignals()
{
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> db(new Database());
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
Group* groupRoot = db->rootGroup();
Group* groupChild = new Group();
Group* groupChildChild = new Group();
groupRoot->setObjectName("groupRoot");
groupChild->setObjectName("groupChild");
groupChildChild->setObjectName("groupChildChild");
groupChild->setParent(groupRoot);
groupChildChild->setParent(groupChild);
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QSignalSpy spyAboutToRemove(db.data(), SIGNAL(groupAboutToRemove(Group*)));
QSignalSpy spyRemoved(db.data(), SIGNAL(groupRemoved()));
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
delete groupChild;
QVERIFY(groupRoot->children().isEmpty());
Stop suppressing signals in Group dtor. That way we emit entry/group removed signals. Move cleanupParent() call to the bottom so we maintain the group tree structure for objects that connect to those signals.
2013-03-22 15:57:18 -04:00
QCOMPARE(spyAboutToRemove.count(), 2);
QCOMPARE(spyRemoved.count(), 2);
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
Group* group = new Group();
Entry* entry = new Entry();
entry->setGroup(group);
QSignalSpy spyEntryAboutToRemove(group, SIGNAL(entryAboutToRemove(Entry*)));
Don't add new entries to EntryModel when in search mode. Only allow moving entries from one group to the other.
2012-07-21 12:19:40 -04:00
QSignalSpy spyEntryRemoved(group, SIGNAL(entryRemoved(Entry*)));
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
delete entry;
QVERIFY(group->entries().isEmpty());
QCOMPARE(spyEntryAboutToRemove.count(), 1);
QCOMPARE(spyEntryRemoved.count(), 1);
delete group;
Clean up group deletion.
2012-04-21 17:31:37 -04:00
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> db2(new Database());
Clean up group deletion.
2012-04-21 17:31:37 -04:00
Group* groupRoot2 = db2->rootGroup();
Group* group2 = new Group();
group2->setParent(groupRoot2);
Entry* entry2 = new Entry();
entry2->setGroup(group2);
QSignalSpy spyEntryAboutToRemove2(group2, SIGNAL(entryAboutToRemove(Entry*)));
Don't add new entries to EntryModel when in search mode. Only allow moving entries from one group to the other.
2012-07-21 12:19:40 -04:00
QSignalSpy spyEntryRemoved2(group2, SIGNAL(entryRemoved(Entry*)));
Clean up group deletion.
2012-04-21 17:31:37 -04:00
delete group2;
Stop suppressing signals in Group dtor. That way we emit entry/group removed signals. Move cleanupParent() call to the bottom so we maintain the group tree structure for objects that connect to those signals.
2013-03-22 15:57:18 -04:00
QCOMPARE(spyEntryAboutToRemove2.count(), 1);
QCOMPARE(spyEntryRemoved2.count(), 1);
Notify entry/group parent on deletion. Also make the root group pseudo static, i.e. it shouldn't be changed after the database has been fully constructed.
2011-07-09 15:54:01 -04:00
}
Copy custom icons when moved to another database. Closes #9
2012-04-27 05:22:02 -04:00
void TestGroup::testCopyCustomIcon()
{
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> dbSource(new Database());
Copy custom icons when moved to another database. Closes #9
2012-04-27 05:22:02 -04:00
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QUuid groupIconUuid = QUuid::createUuid();
Copy custom icons when moved to another database. Closes #9
2012-04-27 05:22:02 -04:00
QImage groupIcon(16, 16, QImage::Format_RGB32);
groupIcon.setPixel(0, 0, qRgb(255, 0, 0));
dbSource->metadata()->addCustomIcon(groupIconUuid, groupIcon);
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QUuid entryIconUuid = QUuid::createUuid();
Copy custom icons when moved to another database. Closes #9
2012-04-27 05:22:02 -04:00
QImage entryIcon(16, 16, QImage::Format_RGB32);
entryIcon.setPixel(0, 0, qRgb(255, 0, 0));
dbSource->metadata()->addCustomIcon(entryIconUuid, entryIcon);
Group* group = new Group();
group->setParent(dbSource->rootGroup());
group->setIcon(groupIconUuid);
QCOMPARE(group->icon(), groupIcon);
Entry* entry = new Entry();
entry->setGroup(dbSource->rootGroup());
entry->setIcon(entryIconUuid);
QCOMPARE(entry->icon(), entryIcon);
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> dbTarget(new Database());
Copy custom icons when moved to another database. Closes #9
2012-04-27 05:22:02 -04:00
group->setParent(dbTarget->rootGroup());
QVERIFY(dbTarget->metadata()->containsCustomIcon(groupIconUuid));
QCOMPARE(dbTarget->metadata()->customIcon(groupIconUuid), groupIcon);
QCOMPARE(group->icon(), groupIcon);
entry->setGroup(dbTarget->rootGroup());
QVERIFY(dbTarget->metadata()->containsCustomIcon(entryIconUuid));
QCOMPARE(dbTarget->metadata()->customIcon(entryIconUuid), entryIcon);
QCOMPARE(entry->icon(), entryIcon);
}
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
void TestGroup::testClone()
{
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> db(new Database());
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Group> originalGroup(new Group());
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
originalGroup->setParent(db->rootGroup());
originalGroup->setName("Group");
originalGroup->setIcon(42);
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Entry> originalGroupEntry(new Entry());
originalGroupEntry->setGroup(originalGroup.data());
Add flags to Entry::clone() for customized cloning.
2013-11-22 07:27:49 -05:00
originalGroupEntry->setTitle("GroupEntryOld");
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
originalGroupEntry->setIcon(43);
Add flags to Entry::clone() for customized cloning.
2013-11-22 07:27:49 -05:00
originalGroupEntry->beginUpdate();
originalGroupEntry->setTitle("GroupEntry");
originalGroupEntry->endUpdate();
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Group> subGroup(new Group());
subGroup->setParent(originalGroup.data());
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
subGroup->setName("SubGroup");
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Entry> subGroupEntry(new Entry());
subGroupEntry->setGroup(subGroup.data());
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
subGroupEntry->setTitle("SubGroupEntry");
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Group> clonedGroup(originalGroup->clone());
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
QVERIFY(!clonedGroup->parentGroup());
QVERIFY(!clonedGroup->database());
QVERIFY(clonedGroup->uuid() != originalGroup->uuid());
QCOMPARE(clonedGroup->name(), QString("Group"));
QCOMPARE(clonedGroup->iconNumber(), 42);
QCOMPARE(clonedGroup->children().size(), 1);
QCOMPARE(clonedGroup->entries().size(), 1);
Entry* clonedGroupEntry = clonedGroup->entries().at(0);
QVERIFY(clonedGroupEntry->uuid() != originalGroupEntry->uuid());
QCOMPARE(clonedGroupEntry->title(), QString("GroupEntry"));
QCOMPARE(clonedGroupEntry->iconNumber(), 43);
Add flags to Entry::clone() for customized cloning.
2013-11-22 07:27:49 -05:00
QCOMPARE(clonedGroupEntry->historyItems().size(), 0);
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
Group* clonedSubGroup = clonedGroup->children().at(0);
QVERIFY(clonedSubGroup->uuid() != subGroup->uuid());
QCOMPARE(clonedSubGroup->name(), QString("SubGroup"));
QCOMPARE(clonedSubGroup->children().size(), 0);
QCOMPARE(clonedSubGroup->entries().size(), 1);
Entry* clonedSubGroupEntry = clonedSubGroup->entries().at(0);
QVERIFY(clonedSubGroupEntry->uuid() != subGroupEntry->uuid());
QCOMPARE(clonedSubGroupEntry->title(), QString("SubGroupEntry"));
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Group> clonedGroupKeepUuid(originalGroup->clone(Entry::CloneNoFlags));
Pass entryFlags to clone() when recursing into sub-groups. Based on https://github.com/keepassx/keepassx/pull/178 by Mois Moshev <mois@monomon.me> Closes #525
2016-09-02 05:47:22 -04:00
QCOMPARE(clonedGroupKeepUuid->entries().at(0)->uuid(), originalGroupEntry->uuid());
QCOMPARE(clonedGroupKeepUuid->children().at(0)->entries().at(0)->uuid(), subGroupEntry->uuid());
Correct memory leaks in TestGroup.cpp
2017-12-12 23:38:23 -05:00
QScopedPointer<Group> clonedGroupNoFlags(originalGroup->clone(Entry::CloneNoFlags, Group::CloneNoFlags));
Adding tests for Group::clone
2017-11-21 14:24:24 -05:00
QCOMPARE(clonedGroupNoFlags->entries().size(), 0);
QVERIFY(clonedGroupNoFlags->uuid() == originalGroup->uuid());
Correct memory leaks in TestGroup.cpp
2017-12-12 23:38:23 -05:00
QScopedPointer<Group> clonedGroupNewUuid(originalGroup->clone(Entry::CloneNoFlags, Group::CloneNewUuid));
Adding tests for Group::clone
2017-11-21 14:24:24 -05:00
QCOMPARE(clonedGroupNewUuid->entries().size(), 0);
QVERIFY(clonedGroupNewUuid->uuid() != originalGroup->uuid());
// Making sure the new modification date is not the same.
Introduce synchronize merge method * Create history-based merging that keeps older data in history instead of discarding or deleting it * Extract merge logic into the Merger class * Allows special merge behavior * Improve handling of deletion and changes on groups * Enable basic change tracking while merging * Prevent unintended timestamp changes while merging * Handle differences in timestamp precision * Introduce comparison operators to allow for more sophisticated comparisons (ignore special properties, ...) * Introduce Clock class to handle datetime across the app Merge Strategies: * Default (use inherited/fallback method) * Duplicate (duplicate conflicting nodes, apply all deletions) * KeepLocal (use local values, but apply all deletions) * KeepRemote (use remote values, but apply all deletions) * KeepNewer (merge history only) * Synchronize (merge history, newest value stays on top, apply all deletions)
2018-09-30 08:45:06 -04:00
m_clock->advanceSecond(1);
Adding tests for Group::clone
2017-11-21 14:24:24 -05:00
Formatting the code.
2018-03-31 16:01:30 -04:00
QScopedPointer<Group> clonedGroupResetTimeInfo(
originalGroup->clone(Entry::CloneNoFlags, Group::CloneNewUuid | Group::CloneResetTimeInfo));
Adding tests for Group::clone
2017-11-21 14:24:24 -05:00
QCOMPARE(clonedGroupResetTimeInfo->entries().size(), 0);
QVERIFY(clonedGroupResetTimeInfo->uuid() != originalGroup->uuid());
Formatting the code.
2018-03-31 16:01:30 -04:00
QVERIFY(clonedGroupResetTimeInfo->timeInfo().lastModificationTime()
!= originalGroup->timeInfo().lastModificationTime());
Add Group::clone(). Move all the data we want to clone into a GroupData struct.
2013-04-04 15:48:55 -04:00
}
Add unit test for Metadata::copyCustomIcons().
2013-04-07 13:38:18 -04:00
void TestGroup::testCopyCustomIcons()
{
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> dbSource(new Database());
QScopedPointer<Database> dbTarget(new Database());
Add unit test for Metadata::copyCustomIcons().
2013-04-07 13:38:18 -04:00
QImage iconImage1(1, 1, QImage::Format_RGB32);
iconImage1.setPixel(0, 0, qRgb(1, 2, 3));
QImage iconImage2(1, 1, QImage::Format_RGB32);
iconImage2.setPixel(0, 0, qRgb(4, 5, 6));
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Group> group1(new Group());
Add unit test for Metadata::copyCustomIcons().
2013-04-07 13:38:18 -04:00
group1->setParent(dbSource->rootGroup());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QUuid group1Icon = QUuid::createUuid();
Add unit test for Metadata::copyCustomIcons().
2013-04-07 13:38:18 -04:00
dbSource->metadata()->addCustomIcon(group1Icon, iconImage1);
group1->setIcon(group1Icon);
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Group> group2(new Group());
group2->setParent(group1.data());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QUuid group2Icon = QUuid::createUuid();
Add unit test for Metadata::copyCustomIcons().
2013-04-07 13:38:18 -04:00
dbSource->metadata()->addCustomIcon(group2Icon, iconImage1);
group2->setIcon(group2Icon);
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Entry> entry1(new Entry());
entry1->setGroup(group2.data());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QUuid entry1IconOld = QUuid::createUuid();
Add unit test for Metadata::copyCustomIcons().
2013-04-07 13:38:18 -04:00
dbSource->metadata()->addCustomIcon(entry1IconOld, iconImage1);
entry1->setIcon(entry1IconOld);
// add history item
entry1->beginUpdate();
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QUuid entry1IconNew = QUuid::createUuid();
Add unit test for Metadata::copyCustomIcons().
2013-04-07 13:38:18 -04:00
dbSource->metadata()->addCustomIcon(entry1IconNew, iconImage1);
entry1->setIcon(entry1IconNew);
entry1->endUpdate();
// test that we don't overwrite icons
dbTarget->metadata()->addCustomIcon(group2Icon, iconImage2);
dbTarget->metadata()->copyCustomIcons(group1->customIconsRecursive(), dbSource->metadata());
Metadata* metaTarget = dbTarget->metadata();
QCOMPARE(metaTarget->customIcons().size(), 4);
QVERIFY(metaTarget->containsCustomIcon(group1Icon));
QVERIFY(metaTarget->containsCustomIcon(group2Icon));
QVERIFY(metaTarget->containsCustomIcon(entry1IconOld));
QVERIFY(metaTarget->containsCustomIcon(entry1IconNew));
QCOMPARE(metaTarget->customIcon(group1Icon).pixel(0, 0), qRgb(1, 2, 3));
QCOMPARE(metaTarget->customIcon(group2Icon).pixel(0, 0), qRgb(4, 5, 6));
}
Add Merge database utility function (#47) Thank you to @TheZ3ro and @monomon for there major contributions to this PR!
2016-11-07 22:37:42 -05:00
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
void TestGroup::testFindEntry()
{
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> db(new Database());
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
Entry* entry1 = new Entry();
entry1->setTitle(QString("entry1"));
entry1->setGroup(db->rootGroup());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
entry1->setUuid(QUuid::createUuid());
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
Group* group1 = new Group();
group1->setName("group1");
Entry* entry2 = new Entry();
entry2->setTitle(QString("entry2"));
entry2->setGroup(group1);
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
entry2->setUuid(QUuid::createUuid());
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
group1->setParent(db->rootGroup());
Entry* entry;
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByUuid(entry1->uuid());
QVERIFY(entry);
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
QCOMPARE(entry->title(), QString("entry1"));
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("entry1"));
QVERIFY(entry);
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
QCOMPARE(entry->title(), QString("entry1"));
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
// We also can find the entry with the leading slash.
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("/entry1"));
QVERIFY(entry);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(entry->title(), QString("entry1"));
// But two slashes should not be accepted.
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("//entry1"));
QVERIFY(!entry);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByUuid(entry2->uuid());
QVERIFY(entry);
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
QCOMPARE(entry->title(), QString("entry2"));
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("group1/entry2"));
QVERIFY(entry);
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
QCOMPARE(entry->title(), QString("entry2"));
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("/entry2"));
QVERIFY(!entry);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
// We also can find the entry with the leading slash.
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("/group1/entry2"));
QVERIFY(entry);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(entry->title(), QString("entry2"));
Find entry by title.
2017-05-21 13:51:16 -04:00
// Should also find the entry only by title.
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("entry2"));
QVERIFY(entry);
Find entry by title.
2017-05-21 13:51:16 -04:00
QCOMPARE(entry->title(), QString("entry2"));
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("invalid/path/to/entry2"));
QVERIFY(!entry);
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByPath(QString("entry27"));
QVERIFY(!entry);
Find entry by title.
2017-05-21 13:51:16 -04:00
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
// A valid UUID that does not exist in this database.
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByUuid(QUuid("febfb01ebcdf9dbd90a3f1579dc75281"));
QVERIFY(!entry);
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
// An invalid UUID.
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
entry = db->rootGroup()->findEntryByUuid(QUuid("febfb01ebcdf9dbd90a3f1579dc"));
QVERIFY(!entry);
// Empty strings
entry = db->rootGroup()->findEntryByUuid({});
QVERIFY(!entry);
entry = db->rootGroup()->findEntryByPath({});
QVERIFY(!entry);
Feature : clip command (#578)
2017-05-19 14:04:11 -04:00
}
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
void TestGroup::testFindGroupByPath()
{
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> db(new Database());
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
Group* group1 = new Group();
group1->setName("group1");
group1->setParent(db->rootGroup());
Group* group2 = new Group();
group2->setName("group2");
group2->setParent(group1);
Group* group;
group = db->rootGroup()->findGroupByPath("/");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), db->rootGroup()->uuid());
// We also accept it if the leading slash is missing.
group = db->rootGroup()->findGroupByPath("");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), db->rootGroup()->uuid());
group = db->rootGroup()->findGroupByPath("/group1/");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), group1->uuid());
// We also accept it if the leading slash is missing.
group = db->rootGroup()->findGroupByPath("group1/");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), group1->uuid());
// Too many slashes at the end
group = db->rootGroup()->findGroupByPath("group1//");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(!group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
// Missing a slash at the end.
group = db->rootGroup()->findGroupByPath("/group1");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), group1->uuid());
// Too many slashes at the start
group = db->rootGroup()->findGroupByPath("//group1");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(!group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
group = db->rootGroup()->findGroupByPath("/group1/group2/");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), group2->uuid());
// We also accept it if the leading slash is missing.
group = db->rootGroup()->findGroupByPath("group1/group2/");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), group2->uuid());
group = db->rootGroup()->findGroupByPath("group1/group2");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
QCOMPARE(group->uuid(), group2->uuid());
group = db->rootGroup()->findGroupByPath("invalid");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(!group);
Adding support for listing a group. (#652) * Adding support for listing a group. * added findGroupByPath * Removing useless asserts. * Code review.
2017-06-21 17:34:49 -04:00
}
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
void TestGroup::testPrint()
{
Fixed memory leaks in non-gui tests Fixed 2 memory leaks in production code and a few in testcases. As a result leak_check_at_exit ASAN option does not need to turned off for non-gui tests. Smart pointers should be used elsewhere for consistency, but the sooner this fixes are delivered, the lesser memory leaks are introduced.
2017-11-27 15:41:58 -05:00
QScopedPointer<Database> db(new Database());
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
QString output = db->rootGroup()->print();
QCOMPARE(output, QString("[empty]\n"));
output = db->rootGroup()->print(true);
QCOMPARE(output, QString("[empty]\n"));
Entry* entry1 = new Entry();
entry1->setTitle(QString("entry1"));
entry1->setGroup(db->rootGroup());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
entry1->setUuid(QUuid::createUuid());
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
output = db->rootGroup()->print();
QCOMPARE(output, QString("entry1\n"));
Group* group1 = new Group();
group1->setName("group1");
CLI: Add 'flatten' option to the 'ls' command (#3276) * Fixes #925 * Add 'flatten' option to CLI ls command * Add test for Group::hierarchy() and man page for ls --flatten * Rename group sort test to align with others
2019-06-18 20:42:19 -04:00
group1->setParent(db->rootGroup());
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
Entry* entry2 = new Entry();
entry2->setTitle(QString("entry2"));
entry2->setGroup(group1);
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
entry2->setUuid(QUuid::createUuid());
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
CLI: Add 'flatten' option to the 'ls' command (#3276) * Fixes #925 * Add 'flatten' option to CLI ls command * Add test for Group::hierarchy() and man page for ls --flatten * Rename group sort test to align with others
2019-06-18 20:42:19 -04:00
Group* group2 = new Group();
group2->setName("group2");
group2->setParent(db->rootGroup());
Group* subGroup = new Group();
subGroup->setName("subgroup");
subGroup->setParent(group2);
Entry* entry3 = new Entry();
entry3->setTitle(QString("entry3"));
entry3->setGroup(subGroup);
entry3->setUuid(QUuid::createUuid());
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
output = db->rootGroup()->print();
QVERIFY(output.contains(QString("entry1\n")));
QVERIFY(output.contains(QString("group1/\n")));
Refactoring : Introducing Command class for CLI commands (#778)
2017-07-17 15:16:53 -04:00
QVERIFY(!output.contains(QString(" entry2\n")));
CLI: Add 'flatten' option to the 'ls' command (#3276) * Fixes #925 * Add 'flatten' option to CLI ls command * Add test for Group::hierarchy() and man page for ls --flatten * Rename group sort test to align with others
2019-06-18 20:42:19 -04:00
QVERIFY(output.contains(QString("group2/\n")));
QVERIFY(!output.contains(QString(" subgroup\n")));
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
output = db->rootGroup()->print(true);
Refactoring : Introducing Command class for CLI commands (#778)
2017-07-17 15:16:53 -04:00
QVERIFY(output.contains(QString("entry1\n")));
QVERIFY(output.contains(QString("group1/\n")));
QVERIFY(output.contains(QString(" entry2\n")));
CLI: Add 'flatten' option to the 'ls' command (#3276) * Fixes #925 * Add 'flatten' option to CLI ls command * Add test for Group::hierarchy() and man page for ls --flatten * Rename group sort test to align with others
2019-06-18 20:42:19 -04:00
QVERIFY(output.contains(QString("group2/\n")));
QVERIFY(output.contains(QString(" subgroup/\n")));
QVERIFY(output.contains(QString(" entry3\n")));
output = db->rootGroup()->print(true, true);
QVERIFY(output.contains(QString("entry1\n")));
QVERIFY(output.contains(QString("group1/\n")));
QVERIFY(output.contains(QString("group1/entry2\n")));
QVERIFY(output.contains(QString("group2/\n")));
QVERIFY(output.contains(QString("group2/subgroup/\n")));
QVERIFY(output.contains(QString("group2/subgroup/entry3\n")));
Refactoring : Introducing Command class for CLI commands (#778)
2017-07-17 15:16:53 -04:00
output = group1->print();
QVERIFY(!output.contains(QString("group1/\n")));
QVERIFY(output.contains(QString("entry2\n")));
CLI: Add 'flatten' option to the 'ls' command (#3276) * Fixes #925 * Add 'flatten' option to CLI ls command * Add test for Group::hierarchy() and man page for ls --flatten * Rename group sort test to align with others
2019-06-18 20:42:19 -04:00
output = group2->print(true, true);
QVERIFY(!output.contains(QString("group2/\n")));
QVERIFY(output.contains(QString("subgroup/\n")));
QVERIFY(output.contains(QString("subgroup/entry3\n")));
Moving print group in Group class. (#586)
2017-05-21 13:05:44 -04:00
}
Adding Locate command. (#829) * Adding Locate command. * Adding group searching in locate
2017-08-05 12:20:26 -04:00
void TestGroup::testLocate()
{
Database* db = new Database();
Entry* entry1 = new Entry();
entry1->setTitle("entry1");
entry1->setGroup(db->rootGroup());
Entry* entry2 = new Entry();
entry2->setTitle("entry2");
entry2->setGroup(db->rootGroup());
Group* group1 = new Group();
group1->setName("group1");
group1->setParent(db->rootGroup());
Group* group2 = new Group();
group2->setName("group2");
group2->setParent(group1);
Entry* entry3 = new Entry();
entry3->setTitle("entry3");
entry3->setGroup(group1);
Entry* entry43 = new Entry();
entry43->setTitle("entry43");
entry43->setGroup(group1);
Entry* google = new Entry();
google->setTitle("Google");
google->setGroup(group2);
QStringList results = db->rootGroup()->locate("entry");
QVERIFY(results.size() == 4);
QVERIFY(results.contains("/group1/entry43"));
results = db->rootGroup()->locate("entry1");
QVERIFY(results.size() == 1);
QVERIFY(results.contains("/entry1"));
results = db->rootGroup()->locate("Entry1");
QVERIFY(results.size() == 1);
QVERIFY(results.contains("/entry1"));
results = db->rootGroup()->locate("invalid");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(results.isEmpty());
Adding Locate command. (#829) * Adding Locate command. * Adding group searching in locate
2017-08-05 12:20:26 -04:00
results = db->rootGroup()->locate("google");
QVERIFY(results.size() == 1);
QVERIFY(results.contains("/group1/group2/Google"));
results = db->rootGroup()->locate("group1");
QVERIFY(results.size() == 3);
QVERIFY(results.contains("/group1/entry3"));
QVERIFY(results.contains("/group1/entry43"));
QVERIFY(results.contains("/group1/group2/Google"));
delete db;
}
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
void TestGroup::testAddEntryWithPath()
{
Database* db = new Database();
Group* group1 = new Group();
group1->setName("group1");
group1->setParent(db->rootGroup());
Group* group2 = new Group();
group2->setName("group2");
group2->setParent(group1);
Entry* entry = db->rootGroup()->addEntryWithPath("entry1");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
QVERIFY(!entry->uuid().isNull());
entry = db->rootGroup()->addEntryWithPath("entry1");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(!entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
entry = db->rootGroup()->addEntryWithPath("/entry1");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(!entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
entry = db->rootGroup()->addEntryWithPath("entry2");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
QVERIFY(entry->title() == "entry2");
QVERIFY(!entry->uuid().isNull());
entry = db->rootGroup()->addEntryWithPath("/entry3");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
QVERIFY(entry->title() == "entry3");
QVERIFY(!entry->uuid().isNull());
entry = db->rootGroup()->addEntryWithPath("/group1/entry4");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
QVERIFY(entry->title() == "entry4");
QVERIFY(!entry->uuid().isNull());
entry = db->rootGroup()->addEntryWithPath("/group1/group2/entry5");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
QVERIFY(entry->title() == "entry5");
QVERIFY(!entry->uuid().isNull());
entry = db->rootGroup()->addEntryWithPath("/group1/invalid_group/entry6");
Fix issues with group functions (#2410)
2018-10-30 08:42:35 -04:00
QVERIFY(!entry);
CLI : basic entry manipulation commands. (#919) * CLI : basic entry manipulation commands. * Code review.
2017-09-06 09:14:41 -04:00
delete db;
}
Select group when adding credentials from browser extension (#2637)
2019-01-30 09:48:22 -05:00
void TestGroup::testIsRecycled()
{
Database* db = new Database();
Prompt to delete recycle bin when disabling it Fixes #3365 Add prompt to delete the recycle bin when disabling it. If the user chooses not to delete it, the recycle bin will be suffixed with "(old)" and the icon changed to the default group icon. Also moved recycle bin creation within the database class where it belongs.
2019-10-12 09:27:35 -04:00
db->metadata()->setRecycleBinEnabled(true);
Select group when adding credentials from browser extension (#2637)
2019-01-30 09:48:22 -05:00
Group* group1 = new Group();
group1->setName("group1");
group1->setParent(db->rootGroup());
Group* group2 = new Group();
group2->setName("group2");
group2->setParent(db->rootGroup());
Group* group3 = new Group();
group3->setName("group3");
group3->setParent(group2);
Group* group4 = new Group();
group4->setName("group4");
group4->setParent(db->rootGroup());
db->recycleGroup(group2);
QVERIFY(!group1->isRecycled());
QVERIFY(group2->isRecycled());
QVERIFY(group3->isRecycled());
QVERIFY(!group4->isRecycled());
db->recycleGroup(group4);
QVERIFY(group4->isRecycled());
}
Fix group signals (#2670) * Fix group not emitting signals when modified through copyDataFrom * Fix Group::GroupData equals wrongly compares timeInfo
2019-02-01 17:03:28 -05:00
void TestGroup::testCopyDataFrom()
{
QScopedPointer<Group> group(new Group());
group->setName("TestGroup");
QScopedPointer<Group> group2(new Group());
group2->setName("TestGroup2");
QScopedPointer<Group> group3(new Group());
group3->setName("TestGroup3");
group3->customData()->set("testKey", "value");
QSignalSpy spyGroupModified(group.data(), SIGNAL(groupModified()));
QSignalSpy spyGroupDataChanged(group.data(), SIGNAL(groupDataChanged(Group*)));
group->copyDataFrom(group2.data());
QCOMPARE(spyGroupModified.count(), 1);
QCOMPARE(spyGroupDataChanged.count(), 1);
// if no change, no signals
spyGroupModified.clear();
spyGroupDataChanged.clear();
group->copyDataFrom(group2.data());
QCOMPARE(spyGroupModified.count(), 0);
QCOMPARE(spyGroupDataChanged.count(), 0);
// custom data change triggers a separate modified signal
spyGroupModified.clear();
spyGroupDataChanged.clear();
group->copyDataFrom(group3.data());
QCOMPARE(spyGroupDataChanged.count(), 1);
QCOMPARE(spyGroupModified.count(), 2);
}
void TestGroup::testEquals()
{
QScopedPointer<Group> group(new Group());
group->setName("TestGroup");
QVERIFY(group->equals(group.data(), CompareItemDefault));
}
Add group sorting feature * Enabling sorting of groups and their children in ascending and descending direction
2019-06-18 16:58:47 -04:00
CLI: Add 'flatten' option to the 'ls' command (#3276) * Fixes #925 * Add 'flatten' option to CLI ls command * Add test for Group::hierarchy() and man page for ls --flatten * Rename group sort test to align with others
2019-06-18 20:42:19 -04:00
void TestGroup::testChildrenSort()
Add group sorting feature * Enabling sorting of groups and their children in ascending and descending direction
2019-06-18 16:58:47 -04:00
{
auto createTestGroupWithUnorderedChildren = []() -> Group* {
Group* parent = new Group();
Group* group1 = new Group();
group1->setName("B");
group1->setParent(parent);
Group* group2 = new Group();
group2->setName("e");
group2->setParent(parent);
Group* group3 = new Group();
group3->setName("Test999");
group3->setParent(parent);
Group* group4 = new Group();
group4->setName("A");
group4->setParent(parent);
Group* group5 = new Group();
group5->setName("z");
group5->setParent(parent);
Group* group6 = new Group();
group6->setName("045");
group6->setParent(parent);
Group* group7 = new Group();
group7->setName("60");
group7->setParent(parent);
Group* group8 = new Group();
group8->setName("04test");
group8->setParent(parent);
Group* group9 = new Group();
group9->setName("Test12");
group9->setParent(parent);
Group* group10 = new Group();
group10->setName("i");
group10->setParent(parent);
Group* subGroup1 = new Group();
subGroup1->setName("sub_xte");
subGroup1->setParent(group10);
Group* subGroup2 = new Group();
subGroup2->setName("sub_010");
subGroup2->setParent(group10);
Group* subGroup3 = new Group();
subGroup3->setName("sub_000");
subGroup3->setParent(group10);
Group* subGroup4 = new Group();
subGroup4->setName("sub_M");
subGroup4->setParent(group10);
Group* subGroup5 = new Group();
subGroup5->setName("sub_p");
subGroup5->setParent(group10);
Group* subGroup6 = new Group();
subGroup6->setName("sub_45p");
subGroup6->setParent(group10);
Group* subGroup7 = new Group();
subGroup7->setName("sub_6p");
subGroup7->setParent(group10);
Group* subGroup8 = new Group();
subGroup8->setName("sub_tt");
subGroup8->setParent(group10);
Group* subGroup9 = new Group();
subGroup9->setName("sub_t0");
subGroup9->setParent(group10);
return parent;
};
Group* parent = createTestGroupWithUnorderedChildren();
Group* subParent = parent->children().last();
parent->sortChildrenRecursively();
QList<Group*> children = parent->children();
QCOMPARE(children.size(), 10);
QCOMPARE(children[0]->name(), QString("045"));
QCOMPARE(children[1]->name(), QString("04test"));
QCOMPARE(children[2]->name(), QString("60"));
QCOMPARE(children[3]->name(), QString("A"));
QCOMPARE(children[4]->name(), QString("B"));
QCOMPARE(children[5]->name(), QString("e"));
QCOMPARE(children[6]->name(), QString("i"));
QCOMPARE(children[7]->name(), QString("Test12"));
QCOMPARE(children[8]->name(), QString("Test999"));
QCOMPARE(children[9]->name(), QString("z"));
children = subParent->children();
QCOMPARE(children.size(), 9);
QCOMPARE(children[0]->name(), QString("sub_000"));
QCOMPARE(children[1]->name(), QString("sub_010"));
QCOMPARE(children[2]->name(), QString("sub_45p"));
QCOMPARE(children[3]->name(), QString("sub_6p"));
QCOMPARE(children[4]->name(), QString("sub_M"));
QCOMPARE(children[5]->name(), QString("sub_p"));
QCOMPARE(children[6]->name(), QString("sub_t0"));
QCOMPARE(children[7]->name(), QString("sub_tt"));
QCOMPARE(children[8]->name(), QString("sub_xte"));
delete parent;
parent = createTestGroupWithUnorderedChildren();
subParent = parent->children().last();
parent->sortChildrenRecursively(true);
children = parent->children();
QCOMPARE(children.size(), 10);
QCOMPARE(children[0]->name(), QString("z"));
QCOMPARE(children[1]->name(), QString("Test999"));
QCOMPARE(children[2]->name(), QString("Test12"));
QCOMPARE(children[3]->name(), QString("i"));
QCOMPARE(children[4]->name(), QString("e"));
QCOMPARE(children[5]->name(), QString("B"));
QCOMPARE(children[6]->name(), QString("A"));
QCOMPARE(children[7]->name(), QString("60"));
QCOMPARE(children[8]->name(), QString("04test"));
QCOMPARE(children[9]->name(), QString("045"));
children = subParent->children();
QCOMPARE(children.size(), 9);
QCOMPARE(children[0]->name(), QString("sub_xte"));
QCOMPARE(children[1]->name(), QString("sub_tt"));
QCOMPARE(children[2]->name(), QString("sub_t0"));
QCOMPARE(children[3]->name(), QString("sub_p"));
QCOMPARE(children[4]->name(), QString("sub_M"));
QCOMPARE(children[5]->name(), QString("sub_6p"));
QCOMPARE(children[6]->name(), QString("sub_45p"));
QCOMPARE(children[7]->name(), QString("sub_010"));
QCOMPARE(children[8]->name(), QString("sub_000"));
delete parent;
parent = createTestGroupWithUnorderedChildren();
subParent = parent->children().last();
subParent->sortChildrenRecursively();
children = parent->children();
QCOMPARE(children.size(), 10);
QCOMPARE(children[0]->name(), QString("B"));
QCOMPARE(children[1]->name(), QString("e"));
QCOMPARE(children[2]->name(), QString("Test999"));
QCOMPARE(children[3]->name(), QString("A"));
QCOMPARE(children[4]->name(), QString("z"));
QCOMPARE(children[5]->name(), QString("045"));
QCOMPARE(children[6]->name(), QString("60"));
QCOMPARE(children[7]->name(), QString("04test"));
QCOMPARE(children[8]->name(), QString("Test12"));
QCOMPARE(children[9]->name(), QString("i"));
children = subParent->children();
QCOMPARE(children.size(), 9);
QCOMPARE(children[0]->name(), QString("sub_000"));
QCOMPARE(children[1]->name(), QString("sub_010"));
QCOMPARE(children[2]->name(), QString("sub_45p"));
QCOMPARE(children[3]->name(), QString("sub_6p"));
QCOMPARE(children[4]->name(), QString("sub_M"));
QCOMPARE(children[5]->name(), QString("sub_p"));
QCOMPARE(children[6]->name(), QString("sub_t0"));
QCOMPARE(children[7]->name(), QString("sub_tt"));
QCOMPARE(children[8]->name(), QString("sub_xte"));
delete parent;
parent = createTestGroupWithUnorderedChildren();
subParent = parent->children().last();
subParent->sortChildrenRecursively(true);
children = parent->children();
QCOMPARE(children.size(), 10);
QCOMPARE(children[0]->name(), QString("B"));
QCOMPARE(children[1]->name(), QString("e"));
QCOMPARE(children[2]->name(), QString("Test999"));
QCOMPARE(children[3]->name(), QString("A"));
QCOMPARE(children[4]->name(), QString("z"));
QCOMPARE(children[5]->name(), QString("045"));
QCOMPARE(children[6]->name(), QString("60"));
QCOMPARE(children[7]->name(), QString("04test"));
QCOMPARE(children[8]->name(), QString("Test12"));
QCOMPARE(children[9]->name(), QString("i"));
children = subParent->children();
QCOMPARE(children.size(), 9);
QCOMPARE(children[0]->name(), QString("sub_xte"));
QCOMPARE(children[1]->name(), QString("sub_tt"));
QCOMPARE(children[2]->name(), QString("sub_t0"));
QCOMPARE(children[3]->name(), QString("sub_p"));
QCOMPARE(children[4]->name(), QString("sub_M"));
QCOMPARE(children[5]->name(), QString("sub_6p"));
QCOMPARE(children[6]->name(), QString("sub_45p"));
QCOMPARE(children[7]->name(), QString("sub_010"));
QCOMPARE(children[8]->name(), QString("sub_000"));
delete parent;
}
CLI: Add 'flatten' option to the 'ls' command (#3276) * Fixes #925 * Add 'flatten' option to CLI ls command * Add test for Group::hierarchy() and man page for ls --flatten * Rename group sort test to align with others
2019-06-18 20:42:19 -04:00
void TestGroup::testHierarchy()
{
Group* group1 = new Group();
group1->setName("group1");
Group* group2 = new Group();
group2->setName("group2");
group2->setParent(group1);
Group* group3 = new Group();
group3->setName("group3");
group3->setParent(group2);
QStringList hierarchy = group3->hierarchy();
QVERIFY(hierarchy.size() == 3);
QVERIFY(hierarchy.contains("group1"));
QVERIFY(hierarchy.contains("group2"));
QVERIFY(hierarchy.contains("group3"));
hierarchy = group3->hierarchy(0);
QVERIFY(hierarchy.size() == 0);
hierarchy = group3->hierarchy(1);
QVERIFY(hierarchy.size() == 1);
QVERIFY(hierarchy.contains("group3"));
hierarchy = group3->hierarchy(2);
QVERIFY(hierarchy.size() == 2);
QVERIFY(hierarchy.contains("group2"));
QVERIFY(hierarchy.contains("group3"));
}
Allow setting group icons to children groups/entries (#3273) * Add combo menu button to apply an icon to children - allow more options to apply icons (child groups, child entries) - extend tests in TestGroup (applying icons for groups/entries only) - prevent blue folder icon being set for entries (on entry creation only) * Do not show the combo menu button for entries
2019-06-19 10:02:07 -04:00
void TestGroup::testApplyGroupIconRecursively()
{
// Create a database with two nested groups with one entry each
Database* database = new Database();
Group* subgroup = new Group();
subgroup->setName("Subgroup");
subgroup->setParent(database->rootGroup());
QVERIFY(subgroup);
Group* subsubgroup = new Group();
subsubgroup->setName("Subsubgroup");
subsubgroup->setParent(subgroup);
QVERIFY(subsubgroup);
Entry* subgroupEntry = subgroup->addEntryWithPath("Subgroup entry");
QVERIFY(subgroupEntry);
subgroup->setIcon(1);
Entry* subsubgroupEntry = subsubgroup->addEntryWithPath("Subsubgroup entry");
QVERIFY(subsubgroupEntry);
subsubgroup->setIcon(2);
// Set an icon per number to the root group and apply recursively
// -> all groups and entries have the same icon
const int rootIconNumber = 42;
database->rootGroup()->setIcon(rootIconNumber);
QVERIFY(database->rootGroup()->iconNumber() == rootIconNumber);
database->rootGroup()->applyGroupIconToChildGroups();
database->rootGroup()->applyGroupIconToChildEntries();
QVERIFY(subgroup->iconNumber() == rootIconNumber);
QVERIFY(subgroupEntry->iconNumber() == rootIconNumber);
QVERIFY(subsubgroup->iconNumber() == rootIconNumber);
QVERIFY(subsubgroupEntry->iconNumber() == rootIconNumber);
// Set an icon per number to the subsubgroup and apply recursively
// -> only the subsubgroup related groups and entries have updated icons
const int subsubgroupIconNumber = 24;
subsubgroup->setIcon(subsubgroupIconNumber);
QVERIFY(subsubgroup->iconNumber() == subsubgroupIconNumber);
subsubgroup->applyGroupIconToChildGroups();
subsubgroup->applyGroupIconToChildEntries();
QVERIFY(database->rootGroup()->iconNumber() == rootIconNumber);
QVERIFY(subgroup->iconNumber() == rootIconNumber);
QVERIFY(subgroupEntry->iconNumber() == rootIconNumber);
QVERIFY(subsubgroup->iconNumber() == subsubgroupIconNumber);
QVERIFY(subsubgroupEntry->iconNumber() == subsubgroupIconNumber);
// Set an icon per UUID to the subgroup and apply recursively
// -> all groups and entries except the root group have the same icon
const QUuid subgroupIconUuid = QUuid::createUuid();
QImage subgroupIcon(16, 16, QImage::Format_RGB32);
subgroupIcon.setPixel(0, 0, qRgb(255, 0, 0));
database->metadata()->addCustomIcon(subgroupIconUuid, subgroupIcon);
subgroup->setIcon(subgroupIconUuid);
subgroup->applyGroupIconToChildGroups();
subgroup->applyGroupIconToChildEntries();
QVERIFY(database->rootGroup()->iconNumber() == rootIconNumber);
QCOMPARE(subgroup->iconUuid(), subgroupIconUuid);
QCOMPARE(subgroup->icon(), subgroupIcon);
QCOMPARE(subgroupEntry->iconUuid(), subgroupIconUuid);
QCOMPARE(subgroupEntry->icon(), subgroupIcon);
QCOMPARE(subsubgroup->iconUuid(), subgroupIconUuid);
QCOMPARE(subsubgroup->icon(), subgroupIcon);
QCOMPARE(subsubgroupEntry->iconUuid(), subgroupIconUuid);
QCOMPARE(subsubgroupEntry->icon(), subgroupIcon);
// Reset all icons to root icon
database->rootGroup()->setIcon(rootIconNumber);
QVERIFY(database->rootGroup()->iconNumber() == rootIconNumber);
database->rootGroup()->applyGroupIconToChildGroups();
database->rootGroup()->applyGroupIconToChildEntries();
QVERIFY(subgroup->iconNumber() == rootIconNumber);
QVERIFY(subgroupEntry->iconNumber() == rootIconNumber);
QVERIFY(subsubgroup->iconNumber() == rootIconNumber);
QVERIFY(subsubgroupEntry->iconNumber() == rootIconNumber);
// Apply only for child groups
const int iconForGroups = 10;
database->rootGroup()->setIcon(iconForGroups);
QVERIFY(database->rootGroup()->iconNumber() == iconForGroups);
database->rootGroup()->applyGroupIconToChildGroups();
QVERIFY(database->rootGroup()->iconNumber() == iconForGroups);
QVERIFY(subgroup->iconNumber() == iconForGroups);
QVERIFY(subgroupEntry->iconNumber() == rootIconNumber);
QVERIFY(subsubgroup->iconNumber() == iconForGroups);
QVERIFY(subsubgroupEntry->iconNumber() == rootIconNumber);
// Apply only for child entries
const int iconForEntries = 20;
database->rootGroup()->setIcon(iconForEntries);
QVERIFY(database->rootGroup()->iconNumber() == iconForEntries);
database->rootGroup()->applyGroupIconToChildEntries();
QVERIFY(database->rootGroup()->iconNumber() == iconForEntries);
QVERIFY(subgroup->iconNumber() == iconForGroups);
QVERIFY(subgroupEntry->iconNumber() == iconForEntries);
QVERIFY(subsubgroup->iconNumber() == iconForGroups);
QVERIFY(subsubgroupEntry->iconNumber() == iconForEntries);
}
Autocomplete usernames based on most frequent in database * Fixes #3126 * Limit autocompletion to the top ten used usernames - Load common usernames when database is opened - Transition from QLineEdit to QComboBox for usernames - Dropdown menu of the combobox lets user choose a common username - Common usernames are autocompleted via inline completion - Common usernames are sorted by frequency (first) and name (second)
2019-06-22 09:38:02 -04:00
void TestGroup::testUsernamesRecursive()
{
Database* database = new Database();
// Create a subgroup
Group* subgroup = new Group();
subgroup->setName("Subgroup");
subgroup->setParent(database->rootGroup());
// Generate entries in the root group and the subgroup
Entry* rootGroupEntry = database->rootGroup()->addEntryWithPath("Root group entry");
rootGroupEntry->setUsername("Name1");
Entry* subgroupEntry = subgroup->addEntryWithPath("Subgroup entry");
subgroupEntry->setUsername("Name2");
Entry* subgroupEntryReusingUsername = subgroup->addEntryWithPath("Another subgroup entry");
subgroupEntryReusingUsername->setUsername("Name2");
QList<QString> usernames = database->rootGroup()->usernamesRecursive();
QCOMPARE(usernames.size(), 2);
QVERIFY(usernames.contains("Name1"));
QVERIFY(usernames.contains("Name2"));
QVERIFY(usernames.indexOf("Name2") < usernames.indexOf("Name1"));
}
Reference in New Issue Copy Permalink