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
058b4da954
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();
db->rootGroup()->createRecycleBin();
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