def test_import_entry(self):
name = 'testimport1'
url = 'http://www.launchpad.net/pasaffe'
user = '******'
password = '******'
note = "This is a note"
rc = subprocess.call([
'bin/pasaffe-import-entry', '-q', '-f', self.test_db, '-m',
'pasaffe', '-e', name, '-l', url, '-u', user, '-p', password, '-n',
note
])
self.assertEqual(rc, 0)
passfile = PassSafeFile(self.test_db, 'pasaffe')
self.assertEqual(len(passfile.records), 4)
# Locate the new entry
for uuid in passfile.records:
if passfile.records[uuid][3] == name:
break
self.assertEqual(passfile.records[uuid][3], name)
self.assertEqual(passfile.records[uuid][4], user)
self.assertEqual(passfile.records[uuid][5], note)
self.assertEqual(passfile.records[uuid][6], password)
self.assertEqual(passfile.records[uuid][13], url)
def setUp(self):
self.tempdir = tempfile.mkdtemp()
self.imported_db = os.path.join(self.tempdir, 'imported.psafe3')
subprocess.call(['bin/pasaffe-import-figaroxml', '-q',
'-f', './tests/databases/figaro-079.xml',
'-d', self.imported_db,
'-y', '-m', 'pasaffe'])
self.passfile = PassSafeFile(self.imported_db, 'pasaffe')
def create_test_db():
passfile = PassSafeFile()
passfile.new_db('pasaffe')
entries, empty_folders = get_test_data()
for entry in entries:
uuid = passfile.new_entry()
for key in entry.keys():
passfile.records[uuid][key] = entry[key]
for folder in empty_folders:
passfile.add_empty_folder(folder)
return passfile
def test_orig_db(self):
passfile = PassSafeFile(self.test_db, 'pasaffe')
self.assertEqual(len(passfile.records), 3)
def setUp(self):
self.passfile = PassSafeFile(
'./tests/databases/pw-gorilla-1537.psafe3', 'pasaffe')
class TestPasswordGorilla1537(unittest.TestCase):
def setUp(self):
self.passfile = PassSafeFile(
'./tests/databases/pw-gorilla-1537.psafe3', 'pasaffe')
def test_num_entries(self):
self.assertEqual(len(self.passfile.records), 6)
def test_empty_folders(self):
# This version of Password Gorilla doesn't save empty folders
self.assertEqual(len(self.passfile.empty_folders), 0)
def test_get_database_version_string(self):
self.assertEqual(self.passfile.get_database_version_string(), "03.00")
def test_get_database_uuid(self):
self.assertEqual(self.passfile.header[1],
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
b'\x00\x00\x00\x00\x00')
def test_get_saved_name(self):
self.assertEqual(self.passfile.get_saved_name(), None)
def test_get_saved_host(self):
self.assertEqual(self.passfile.get_saved_host(), None)
def test_get_saved_application(self):
self.assertEqual(self.passfile.get_saved_application(), None)
def test_get_saved_date_string(self):
self.assertEqual(self.passfile.get_saved_date_string(), None)
def test_entry_1(self):
uuid = '009eeceaad754732634e37d2f70b0985'
self.assertEqual(self.passfile.records[uuid][2], 'top\\.withdot')
self.assertEqual(self.passfile.get_folder_list(uuid), ['top.withdot'])
self.assertEqual(self.passfile.records[uuid][3], 'insidedot')
self.assertEqual(self.passfile.records[uuid][4], 'usernamedot')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'passworddot')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Sat, 25 Oct 2014 15:05:30')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Sat, 25 Oct 2014 15:05:30')
def test_entry_2(self):
uuid = 'd68cee64c2794300561837e248abddd1'
self.assertFalse(2 in self.passfile.records[uuid])
self.assertEqual(self.passfile.get_folder_list(uuid), [])
self.assertEqual(self.passfile.records[uuid][3], 'toplevel1')
self.assertEqual(self.passfile.records[uuid][4], 'usernametop')
self.assertEqual(self.passfile.records[uuid][5], 'This is a note')
self.assertEqual(self.passfile.records[uuid][6], 'passwordtop')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Sat, 25 Oct 2014 15:04:48')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Sat, 25 Oct 2014 15:04:48')
def test_entry_3(self):
uuid = '8e869cc656a942fd7beecf36605140d8'
self.assertEqual(self.passfile.records[uuid][2],
'topgroup1.topgroup2.topgroup3')
self.assertEqual(self.passfile.get_folder_list(uuid),
['topgroup1', 'topgroup2', 'topgroup3'])
self.assertEqual(self.passfile.records[uuid][3], 'entrylevel3')
self.assertEqual(self.passfile.records[uuid][4], 'username3')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'password3')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Sat, 25 Oct 2014 15:06:51')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Sat, 25 Oct 2014 15:06:51')
def test_entry_4(self):
uuid = '3e317b83f4d645056abc5526f9c1f7e6'
self.assertEqual(self.passfile.records[uuid][2], 'topgroup1')
self.assertEqual(self.passfile.get_folder_list(uuid), ['topgroup1'])
self.assertEqual(self.passfile.records[uuid][3], 'entrylevel1')
self.assertEqual(self.passfile.records[uuid][4], 'username1')
self.assertEqual(self.passfile.records[uuid][5],
'This is a note\nThis is a second line\n'
'Unicode: éléphant')
self.assertEqual(self.passfile.records[uuid][6], 'password1')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Sat, 25 Oct 2014 15:07:24')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Sat, 25 Oct 2014 15:07:24')
def test_entry_5(self):
uuid = '11fbf64e83e240a25e8bb657cea6edcd'
self.assertFalse(2 in self.passfile.records[uuid])
self.assertEqual(self.passfile.get_folder_list(uuid), [])
self.assertEqual(self.passfile.records[uuid][3], 'topnopass')
self.assertEqual(self.passfile.records[uuid][4], 'topusername')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], '')
self.assertEqual(self.passfile.get_password_time(uuid, False),
None)
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Sat, 25 Oct 2014 15:07:52')
def test_entry_6(self):
uuid = 'd0b7295a7fc447fa4d8c1aa701ba8c30'
self.assertFalse(2 in self.passfile.records[uuid])
self.assertEqual(self.passfile.get_folder_list(uuid), [])
self.assertEqual(self.passfile.records[uuid][3], 'topnouser')
self.assertEqual(self.passfile.records[uuid][4], '')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'toppassword')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Sat, 25 Oct 2014 15:07:40')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Sat, 25 Oct 2014 15:07:40')
def setUp(self):
self.passfile = PassSafeFile('./tests/databases/pwsafe-331.psafe3',
'pasaffe')
class TestPasswordSafe331(unittest.TestCase):
def setUp(self):
self.passfile = PassSafeFile('./tests/databases/pwsafe-331.psafe3',
'pasaffe')
def test_num_entries(self):
self.assertEqual(len(self.passfile.records), 3)
def test_empty_folders(self):
empty_folders = [['emptygroup1'], ['emptygroup1', 'emptygroup2'],
['emptygroup1', 'emptygroup2', 'emptygroup3'],
['level1group',
'level2group'], ['emptygroup1', 'test'],
['emptygroup1', 'with/slash']]
empty_fields = [
'emptygroup1', 'emptygroup1.emptygroup2',
'emptygroup1.emptygroup2.emptygroup3', 'level1group.level2group',
'emptygroup1.test', 'emptygroup1.with/slash'
]
self.assertEqual(len(self.passfile.empty_folders), len(empty_fields))
self.assertEqual(self.passfile.get_empty_folders(), empty_folders)
self.assertEqual(self.passfile.empty_folders, empty_fields)
def test_get_database_version_string(self):
self.assertEqual(self.passfile.get_database_version_string(), "03.0b")
def test_get_database_uuid(self):
self.assertEqual(self.passfile.header[1],
b'cf\xfe\xea\x00wBU\xa2TM\xc3k\x0f>\x0f')
def test_get_saved_name(self):
self.assertEqual(self.passfile.get_saved_name(), "mdeslaur")
def test_get_saved_host(self):
self.assertEqual(self.passfile.get_saved_host(), "mdlinux")
def test_get_saved_application(self):
self.assertEqual(self.passfile.get_saved_application(),
'Password Safe V3.31')
def test_get_saved_date_string(self):
self.assertEqual(self.passfile.get_saved_date_string(False),
'Thu, 25 Jul 2013 23:57:08')
def test_entry_1(self):
uuid = '4a32a8ad616343b692e85c721bfce0e2'
self.assertFalse(2 in self.passfile.records[uuid])
self.assertEqual(self.passfile.get_folder_list(uuid), [])
self.assertEqual(self.passfile.records[uuid][3], 'topentry1')
self.assertEqual(self.passfile.records[uuid][4], 'username1')
self.assertEqual(
self.passfile.records[uuid][5],
'This is a note\nThis is a second line\n'
'Unicode: éléphant')
self.assertEqual(self.passfile.records[uuid][6], 'password1')
self.assertEqual(self.passfile.get_creation_time(uuid, False),
'Thu, 25 Jul 2013 00:21:00')
self.assertEqual(self.passfile.records[uuid][13],
'http://www.example.com')
def test_entry_2(self):
uuid = '722328d418584201803a119fa517b799'
self.assertEqual(self.passfile.records[uuid][2], 'level1group')
self.assertEqual(self.passfile.get_folder_list(uuid), ['level1group'])
self.assertEqual(self.passfile.records[uuid][3], 'level1entry')
self.assertEqual(self.passfile.records[uuid][4], 'username1')
self.assertEqual(self.passfile.records[uuid][5], 'This is a note\n')
self.assertEqual(self.passfile.records[uuid][6], 'password1')
self.assertEqual(self.passfile.get_creation_time(uuid, False),
'Thu, 25 Jul 2013 00:25:42')
def test_entry_3(self):
uuid = 'cb16d230853247ad8cb12ef6ea615cb4'
self.assertEqual(self.passfile.records[uuid][2],
'level1group.level2group.level3group')
self.assertEqual(self.passfile.get_folder_list(uuid),
['level1group', 'level2group', 'level3group'])
self.assertEqual(self.passfile.records[uuid][3], 'level3entry')
self.assertEqual(self.passfile.records[uuid][4], 'usernamelevel3')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'passwordlevel3')
self.assertEqual(self.passfile.get_creation_time(uuid, False),
'Thu, 25 Jul 2013 00:26:36')
class TestPasswordGorilla15363(unittest.TestCase):
def setUp(self):
self.passfile = PassSafeFile(
'./tests/databases/pw-gorilla-15363.psafe3', 'pasaffe')
def test_num_entries(self):
self.assertEqual(len(self.passfile.records), 4)
def test_empty_folders(self):
# This version of Password Gorilla doesn't save empty folders
self.assertEqual(len(self.passfile.empty_folders), 0)
def test_get_database_version_string(self):
self.assertEqual(self.passfile.get_database_version_string(), "03.00")
def test_get_database_uuid(self):
self.assertEqual(
self.passfile.header[1],
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
b'\x00\x00\x00\x00\x00')
def test_get_saved_name(self):
self.assertEqual(self.passfile.get_saved_name(), None)
def test_get_saved_host(self):
self.assertEqual(self.passfile.get_saved_host(), None)
def test_get_saved_application(self):
self.assertEqual(self.passfile.get_saved_application(), None)
def test_get_saved_date_string(self):
self.assertEqual(self.passfile.get_saved_date_string(), None)
def test_entry_1(self):
uuid = '8642342dfd444e044f50ca8b3b12fd67'
self.assertEqual(self.passfile.records[uuid][2], 'top\\.withdot')
self.assertEqual(self.passfile.get_folder_list(uuid), ['top.withdot'])
self.assertEqual(self.passfile.records[uuid][3], 'insidedot')
self.assertEqual(self.passfile.records[uuid][4], 'usernamedot')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'passworddot')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Thu, 25 Jul 2013 23:58:56')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Thu, 25 Jul 2013 23:58:56')
def test_entry_2(self):
uuid = '666b02ae0f574d4549f8f57ddae70d77'
self.assertFalse(2 in self.passfile.records[uuid])
self.assertEqual(self.passfile.get_folder_list(uuid), [])
self.assertEqual(self.passfile.records[uuid][3], 'toplevel1')
self.assertEqual(self.passfile.records[uuid][4], 'usernametop')
self.assertEqual(self.passfile.records[uuid][5], 'This is a note')
self.assertEqual(self.passfile.records[uuid][6], 'passwordtop')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Thu, 25 Jul 2013 23:58:06')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Thu, 25 Jul 2013 23:58:06')
def test_entry_3(self):
uuid = 'aff6f326353f4be86009bf342e0a0af7'
self.assertEqual(self.passfile.records[uuid][2],
'topgroup1.topgroup2.topgroup3')
self.assertEqual(self.passfile.get_folder_list(uuid),
['topgroup1', 'topgroup2', 'topgroup3'])
self.assertEqual(self.passfile.records[uuid][3], 'entrylevel3')
self.assertEqual(self.passfile.records[uuid][4], 'username3')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'password3')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Thu, 25 Jul 2013 00:33:33')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Thu, 25 Jul 2013 00:33:33')
def test_entry_4(self):
uuid = '66d1cf5e60dc424d6a3b19c89aed2f1e'
self.assertEqual(self.passfile.records[uuid][2], 'topgroup1')
self.assertEqual(self.passfile.get_folder_list(uuid), ['topgroup1'])
self.assertEqual(self.passfile.records[uuid][3], 'entrylevel1')
self.assertEqual(self.passfile.records[uuid][4], 'username1')
self.assertEqual(
self.passfile.records[uuid][5],
'This is a note\nThis is a second line\n'
'Unicode: éléphant')
self.assertEqual(self.passfile.records[uuid][6], 'password1')
self.assertEqual(self.passfile.get_password_time(uuid, False),
'Thu, 25 Jul 2013 00:33:06')
self.assertEqual(self.passfile.get_modification_time(uuid, False),
'Thu, 25 Jul 2013 00:33:06')
def setUp(self):
self.passfile = PassSafeFile('./tests/databases/passwdsafe-510.psafe3',
'pasaffe')
class TestPasswdSafeAndroid510(unittest.TestCase):
def setUp(self):
self.passfile = PassSafeFile('./tests/databases/passwdsafe-510.psafe3',
'pasaffe')
def test_num_entries(self):
self.assertEqual(len(self.passfile.records), 4)
def test_empty_folders(self):
self.assertEqual(len(self.passfile.empty_folders), 0)
def test_get_database_version_string(self):
self.assertEqual(self.passfile.get_database_version_string(), "03.0d")
def test_get_database_uuid(self):
self.assertEqual(self.passfile.header[1],
b'b\xfb\x00\x00\x9al2\x13\x05\xb8\xccnh\x81L\xb5')
def test_get_saved_name(self):
self.assertEqual(self.passfile.get_saved_name(), 'User')
def test_get_saved_host(self):
self.assertEqual(self.passfile.get_saved_host(), 'Galaxy Nexus')
def test_get_saved_application(self):
self.assertEqual(self.passfile.get_saved_application(),
'PasswdSafe 5.1.0')
def test_get_saved_date_string(self):
self.assertEqual(self.passfile.get_saved_date_string(),
'Sat, 25 Oct 2014 12:05:42')
def test_entry_1(self):
uuid = 'af5304edb06c32131d502487eeb21009'
self.assertEqual(self.passfile.records[uuid][2], 'Toplevel2')
self.assertEqual(self.passfile.get_folder_list(uuid), ['Toplevel2'])
self.assertEqual(self.passfile.records[uuid][3], 'Intoplevel2')
self.assertEqual(self.passfile.records[uuid][4], 'username')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'password')
self.assertFalse(8 in self.passfile.records[uuid])
self.assertFalse(12 in self.passfile.records[uuid])
def test_entry_2(self):
uuid = '7f1f06b3a36c3213061dc476b88f83fd'
self.assertFalse(2 in self.passfile.records[uuid])
self.assertEqual(self.passfile.get_folder_list(uuid), [])
self.assertEqual(self.passfile.records[uuid][3], 'Toplevel')
self.assertEqual(self.passfile.records[uuid][4], 'topuser')
self.assertEqual(
self.passfile.records[uuid][5],
'This is a note\n' + 'This is line 2\n' + 'Unicode: éléphant')
self.assertEqual(self.passfile.records[uuid][6], 'toppass')
self.assertFalse(8 in self.passfile.records[uuid])
self.assertFalse(12 in self.passfile.records[uuid])
def test_entry_3(self):
uuid = '82bd036bb86c32130facf0a8e3e3809b'
self.assertEqual(self.passfile.records[uuid][2], 'Top.withdot')
self.assertEqual(self.passfile.get_folder_list(uuid),
['Top', 'withdot'])
self.assertEqual(self.passfile.records[uuid][3], 'Indot')
self.assertEqual(self.passfile.records[uuid][4], '')
self.assertFalse(5 in self.passfile.records[uuid])
self.assertEqual(self.passfile.records[uuid][6], 'password')
self.assertFalse(8 in self.passfile.records[uuid])
self.assertFalse(12 in self.passfile.records[uuid])
def test_entry_4(self):
uuid = '116301c0aa6c321334769a2131e417c5'
self.assertEqual(self.passfile.records[uuid][2], 'Toplevel1')
self.assertEqual(self.passfile.get_folder_list(uuid), ['Toplevel1'])
self.assertEqual(self.passfile.records[uuid][3], 'Intoplevel1')
self.assertEqual(self.passfile.records[uuid][4], 'username')
self.assertEqual(self.passfile.records[uuid][6], 'password')
self.assertEqual(self.passfile.records[uuid][13],
'http://www.example.com')
self.assertFalse(8 in self.passfile.records[uuid])
self.assertFalse(12 in self.passfile.records[uuid])
def setUp(self):
self.passfile = PassSafeFile()
class TestReadDB(unittest.TestCase):
def setUp(self):
self.passfile = PassSafeFile()
def test_folder_list_to_field(self):
folder_list = [
[[], ""],
[["foldera"], "foldera"],
[["folder.a"], "folder\.a"], # noqa: W605
[["foldera."], "foldera\."], # noqa: W605
[[".foldera"], "\.foldera"], # noqa: W605
[["foldera.", "folderb."], "foldera\..folderb\."], # noqa: W605
[["foldera", "folderb"], "foldera.folderb"],
[["folder.a", "folderb"], "folder\.a.folderb"], # noqa: W605
[["foldera", "folder.b"], "foldera.folder\.b"],
[["folder.a", "folder.b"], "folder\.a.folder\.b"],
[["folder.a", "folder.b", "folder.c"],
"folder\.a.folder\.b.folder\.c"],
[["", "foldera", "folderb"], ".foldera.folderb"],
[["", "", "folderb"], "..folderb"],
[["foldera", "", "folderb"], "foldera..folderb"],
[["foldera", "folderb", ""], "foldera.folderb."],
]
for (folder, field) in folder_list:
self.assertEqual(self.passfile._folder_list_to_field(folder),
field)
def test_field_to_folder_list(self):
folder_list = [
["", []],
["foldera", ["foldera"]],
["folder\.a", ["folder.a"]], # noqa: W605
["foldera\.", ["foldera."]], # noqa: W605
["\.foldera", [".foldera"]], # noqa: W605
["foldera\..folderb\.", ["foldera.", "folderb."]], # noqa: W605
["foldera.folderb", ["foldera", "folderb"]],
["folder\.a.folderb", ["folder.a", "folderb"]],
["foldera.folder\.b", ["foldera", "folder.b"]],
["folder\.a.folder\.b", ["folder.a", "folder.b"]],
[
"folder\.a.folder\.b.folder\.c",
["folder.a", "folder.b", "folder.c"]
],
[".foldera.folderb", ["", "foldera", "folderb"]],
["..folderb", ["", "", "folderb"]],
["foldera..folderb", ["foldera", "", "folderb"]],
["foldera.folderb.", ["foldera", "folderb", ""]],
]
for (field, folder) in folder_list:
self.assertEqual(self.passfile._field_to_folder_list(field),
folder)
def test_get_database_version_string(self):
self.passfile.new_db("test")
expected = '%s.%s' % (hexlify(self.passfile.db_version[1:2]).decode(
'utf-8'), hexlify(self.passfile.db_version[0:1]).decode('utf-8'))
self.assertEqual(self.passfile.get_database_version_string(), expected)
self.passfile.header[0] = b'\x0B\x03'
self.assertEqual(self.passfile.get_database_version_string(), "03.0b")
def test_new_entry(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
self.assertEqual(len(uuid_hex), 32)
self.assertTrue(uuid_hex in self.passfile.records)
for field in [1, 3, 4, 5, 6, 7, 8, 12, 13]:
self.assertTrue(field in self.passfile.records[uuid_hex])
def test_delete_entry(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
self.assertTrue(uuid_hex in self.passfile.records)
self.passfile.delete_entry(uuid_hex)
self.assertTrue(uuid_hex not in self.passfile.records)
def test_update_modification_time(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
old_time = self.passfile.records[uuid_hex][12]
time.sleep(1.1)
self.passfile.update_modification_time(uuid_hex)
new_time = self.passfile.records[uuid_hex][12]
self.assertTrue(old_time != new_time)
def test_update_password_time(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
old_time = self.passfile.records[uuid_hex][8]
time.sleep(1.1)
self.passfile.update_password_time(uuid_hex)
new_time = self.passfile.records[uuid_hex][8]
self.assertTrue(old_time != new_time)
def test_get_title(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
test_title = "Test title"
self.passfile.records[uuid_hex][3] = test_title
title = self.passfile.get_title(uuid_hex)
self.assertTrue(title == test_title)
def test_get_username(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
test_username = "******"
self.passfile.records[uuid_hex][4] = test_username
username = self.passfile.get_username(uuid_hex)
self.assertTrue(username == test_username)
def test_get_notes(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
test_note = "This is a note."
self.passfile.records[uuid_hex][5] = test_note
note = self.passfile.get_notes(uuid_hex)
self.assertTrue(note == test_note)
def test_get_password(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
test_password = "******"
self.passfile.records[uuid_hex][6] = test_password
password = self.passfile.get_password(uuid_hex)
self.assertTrue(password == test_password)
def test_get_url(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
test_url = "http://www.example.com"
self.passfile.records[uuid_hex][13] = test_url
url = self.passfile.get_url(uuid_hex)
self.assertTrue(url == test_url)
def test_update_folder_list(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
self.assertTrue(2 not in self.passfile.records[uuid_hex])
folder = ['folderA', 'folderB', 'folderC']
folder_field = 'folderA.folderB.folderC'
self.passfile.update_folder_list(uuid_hex, folder)
self.assertTrue(2 in self.passfile.records[uuid_hex])
self.assertTrue(self.passfile.records[uuid_hex][2] == folder_field)
self.passfile.update_folder_list(uuid_hex, [])
self.assertTrue(2 not in self.passfile.records[uuid_hex])
def test_get_folder_list(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
self.assertTrue(2 not in self.passfile.records[uuid_hex])
self.assertTrue(self.passfile.get_folder_list(uuid_hex) == [])
folder = ['folderA', 'folderB', 'folderC']
folder_field = 'folderA.folderB.folderC'
self.passfile.update_folder_list(uuid_hex, folder)
self.assertTrue(2 in self.passfile.records[uuid_hex])
self.assertTrue(self.passfile.records[uuid_hex][2] == folder_field)
self.assertTrue(self.passfile.get_folder_list(uuid_hex) == folder)
self.assertTrue(self.passfile.get_folder_list('nonexistent') == [])
def test_get_empty_folders(self):
folder_fields = [
'folderA', 'folderA.folderB', 'folderA.folderB.folderC'
]
folder_list = [['folderA'], ['folderA', 'folderB'],
['folderA', 'folderB', 'folderC']]
self.assertTrue(self.passfile.get_empty_folders() == [])
self.passfile.empty_folders = folder_fields
self.assertTrue(self.passfile.get_empty_folders() == folder_list)
def test_add_empty_folder(self):
folder_fields = [
'folderA', 'folderA.folderB', 'folderA.folderB.folderC'
]
folder = ['folderA', 'folderB', 'folderC']
# Make sure it's empty
self.assertTrue(self.passfile.empty_folders == [])
# Add a folder, and make sure it created the children
self.passfile.add_empty_folder(folder)
self.assertTrue(self.passfile.empty_folders == folder_fields)
# Make sure empty parameters work
self.passfile.add_empty_folder(None)
self.assertTrue(self.passfile.empty_folders == folder_fields)
self.passfile.add_empty_folder([])
self.assertTrue(self.passfile.empty_folders == folder_fields)
# Try adding it again, to make sure we don't have duplicates
self.passfile.add_empty_folder(folder)
self.assertTrue(self.passfile.empty_folders == folder_fields)
# Make sure adding an empty folder that isn't actually empty
# works
uuid_hex = self.passfile.new_entry()
entry_folder = ['otherA']
self.passfile.update_folder_list(uuid_hex, entry_folder)
self.passfile.add_empty_folder(entry_folder)
self.assertTrue(self.passfile.empty_folders == folder_fields)
# Adding an empty folder that only has an empty subfolder should
# only add the subfolder
uuid_hex = self.passfile.new_entry()
entry_folder = ['thirdA', 'thirdB']
self.passfile.update_folder_list(uuid_hex, entry_folder)
self.passfile.add_empty_folder(entry_folder)
folder_fields.append('thirdA')
self.assertTrue(self.passfile.empty_folders == folder_fields)
# Do the same, but for 3 levels
uuid_hex = self.passfile.new_entry()
entry_folder = ['fourthA', 'fourthB', 'fourthC']
self.passfile.update_folder_list(uuid_hex, entry_folder)
self.passfile.add_empty_folder(entry_folder)
folder_fields.append('fourthA')
folder_fields.append('fourthA.fourthB')
self.assertTrue(self.passfile.empty_folders == folder_fields)
def test_remove_empty_folder(self):
folder_fields = [
'folderA', 'folderA.folderB', 'folderA.folderB.folderC'
]
# pass by value
self.passfile.empty_folders = folder_fields[:]
# Try and remove a bogus folder
self.passfile.remove_empty_folder(['bogus'])
self.assertTrue(self.passfile.empty_folders == folder_fields)
# Make sure empty parameters work
self.passfile.remove_empty_folder(None)
self.assertTrue(self.passfile.empty_folders == folder_fields)
self.passfile.remove_empty_folder([])
self.assertTrue(self.passfile.empty_folders == folder_fields)
# Now, remove an empty folder
self.passfile.remove_empty_folder(['folderA', 'folderB'])
folder_fields.remove('folderA.folderB')
self.assertTrue(self.passfile.empty_folders == folder_fields)
def test_get_all_folders(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
# First make sure there's no folders at all
self.assertTrue(self.passfile.get_all_folders() == [])
# Now handle an entry, but no empty folders
folder = ['folderA', 'folderB']
self.passfile.update_folder_list(uuid_hex, folder)
self.assertTrue(self.passfile.get_all_folders() == [folder])
# Now handle empty folders, but no entry
self.passfile.update_folder_list(uuid_hex, [])
self.assertTrue(self.passfile.get_all_folders() == [])
folder_fields = [
'folderA', 'folderA.folderB', 'folderA.folderB.folderC'
]
self.passfile.empty_folders = folder_fields
folder_list = [['folderA'], ['folderA', 'folderB'],
['folderA', 'folderB', 'folderC']]
self.assertTrue(self.passfile.get_all_folders() == folder_list)
# Now handle multiple entries, and empty folders
self.passfile.update_folder_list(uuid_hex, folder)
folderB = ['OtherFolderA', 'OtherFolderB']
uuid_hex_B = self.passfile.new_entry()
self.passfile.new_entry()
self.passfile.update_folder_list(uuid_hex_B, folderB)
all_folders = folder_list + [folderB]
self.assertTrue(self.passfile.get_all_folders() == all_folders)
def test_rename_folder_list(self):
self.passfile.new_db("test")
# Create a few entries
folderA = ['firstA', 'firstB']
folderB = ['firstA', 'firstB', 'firstC']
folderC = ['secondA', 'secondB']
uuid_hex_A = self.passfile.new_entry()
uuid_hex_B = self.passfile.new_entry()
uuid_hex_C = self.passfile.new_entry()
uuid_hex_D = self.passfile.new_entry()
self.passfile.update_folder_list(uuid_hex_A, folderA)
self.passfile.update_folder_list(uuid_hex_B, folderB)
self.passfile.update_folder_list(uuid_hex_C, folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_A) == folderA)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_B) == folderB)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
# Ok, let's rename one
new_folderA = ['firstA', 'renamedB']
new_folderB = ['firstA', 'renamedB', 'firstC']
self.passfile.rename_folder_list(folderA, new_folderA)
self.assertTrue(
self.passfile.get_folder_list(uuid_hex_A) == new_folderA)
self.assertTrue(
self.passfile.get_folder_list(uuid_hex_B) == new_folderB)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
# Now add some empty_folders
folder_fields = ['firstA', 'secondA', 'thirdA', 'thirdA.thirdB']
# pass by value
self.passfile.empty_folders = folder_fields[:]
# OK, rename entries and empty_folders
another_new_folderA = ['renamedA', 'renamedB']
another_new_folderB = ['renamedA', 'renamedB', 'firstC']
new_empty_folders = [['secondA'], ['thirdA'], ['thirdA', 'thirdB'],
['renamedA']]
self.passfile.rename_folder_list(['firstA'], ['renamedA'])
self.assertTrue(
self.passfile.get_folder_list(uuid_hex_A) == another_new_folderA)
self.assertTrue(
self.passfile.get_folder_list(uuid_hex_B) == another_new_folderB)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
self.assertTrue(self.passfile.get_empty_folders() == new_empty_folders)
def test_delete_folder(self):
self.passfile.new_db("test")
# Create a few entries
folderA = ['firstA', 'firstB']
folderB = ['firstA', 'firstB', 'firstC']
folderC = ['secondA', 'secondB']
uuid_hex_A = self.passfile.new_entry()
uuid_hex_B = self.passfile.new_entry()
uuid_hex_C = self.passfile.new_entry()
uuid_hex_D = self.passfile.new_entry()
self.passfile.update_folder_list(uuid_hex_A, folderA)
self.passfile.update_folder_list(uuid_hex_B, folderB)
self.passfile.update_folder_list(uuid_hex_C, folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_A) == folderA)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_B) == folderB)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
self.assertTrue(self.passfile.get_empty_folders() == [])
# Try and delete some invalid things
self.passfile.delete_folder(None)
self.passfile.delete_folder([])
self.passfile.delete_folder(['banana'])
self.assertTrue(self.passfile.get_folder_list(uuid_hex_A) == folderA)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_B) == folderB)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
self.assertTrue(self.passfile.get_empty_folders() == [])
# Now, delete a third level.
self.passfile.delete_folder(folderB)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_A) == folderA)
self.assertTrue(uuid_hex_B not in self.passfile.records)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
self.assertTrue(uuid_hex_D in self.passfile.records)
self.assertTrue(self.passfile.get_empty_folders() == [])
# Add some empty_folders and delete a toplevel
emptyA = [['firstA'], ['firstA', 'firstB', 'emptyC']]
emptyB = emptyA + [['some'], ['some', 'random']]
for folder in emptyB:
self.passfile.add_empty_folder(folder)
self.assertTrue(self.passfile.get_empty_folders() == emptyB)
self.passfile.delete_folder(['some'])
self.assertTrue(self.passfile.get_empty_folders() == emptyA)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_A) == folderA)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
self.assertTrue(uuid_hex_D in self.passfile.records)
# Now delete a top level
self.passfile.delete_folder(['firstA'])
self.assertTrue(self.passfile.get_empty_folders() == [])
self.assertTrue(uuid_hex_A not in self.passfile.records)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_C) == folderC)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
self.assertTrue(uuid_hex_D in self.passfile.records)
# Delete the remaining second level. We should gain an empty folder.
self.passfile.delete_folder(['secondA', 'secondB'])
self.assertTrue(uuid_hex_C not in self.passfile.records)
self.assertTrue(self.passfile.get_folder_list(uuid_hex_D) == [])
self.assertTrue(uuid_hex_D in self.passfile.records)
self.assertTrue(self.passfile.get_empty_folders() == [['secondA']])
def test_get_tree_status(self):
self.passfile.new_db("test")
self.assertEqual(self.passfile.get_tree_status(), None)
self.passfile.header[6] = "Pasaffe test"
self.assertEqual(self.passfile.get_tree_status(), None)
self.passfile.header[3] = "101010"
self.assertEqual(self.passfile.get_tree_status(), "101010")
self.passfile.header[6] = "AnotherApp v1"
self.assertEqual(self.passfile.get_tree_status(), None)
def test_set_tree_status(self):
self.passfile.new_db("test")
self.passfile.header[6] = "Pasaffe test"
self.assertEqual(self.passfile.get_tree_status(), None)
self.passfile.set_tree_status("101010")
self.assertEqual(self.passfile.get_tree_status(), "101010")
self.assertTrue(3 in self.passfile.header)
self.passfile.set_tree_status(None)
self.assertEqual(self.passfile.get_tree_status(), None)
self.assertFalse(3 in self.passfile.header)
def test_fixups(self):
self.passfile.new_db("test")
uuid_hex = self.passfile.new_entry()
# New entry should have empty strings
self.assertEqual(self.passfile.records[uuid_hex][3], '')
self.assertEqual(self.passfile.records[uuid_hex][4], '')
self.assertEqual(self.passfile.records[uuid_hex][5], '')
self.assertEqual(self.passfile.records[uuid_hex][6], '')
# Delete title, username and password
del self.passfile.records[uuid_hex][3]
del self.passfile.records[uuid_hex][4]
del self.passfile.records[uuid_hex][6]
# add a comment with CRLF terminators
crlf = ("First line\r\n" + "Second line\r\n" + "Third line")
lf = ("First line\n" + "Second line\n" + "Third line")
self.passfile.records[uuid_hex][5] = crlf
self.assertTrue(3 not in self.passfile.records[uuid_hex])
self.assertTrue(4 not in self.passfile.records[uuid_hex])
self.assertTrue(6 not in self.passfile.records[uuid_hex])
self.assertEqual(self.passfile.records[uuid_hex][5], crlf)
# Now do the postread fixup
self.passfile._postread_fixup()
self.assertEqual(self.passfile.records[uuid_hex][3], '')
self.assertEqual(self.passfile.records[uuid_hex][4], '')
self.assertEqual(self.passfile.records[uuid_hex][5], lf)
self.assertEqual(self.passfile.records[uuid_hex][6], '')
# OK, do the presave fixup
self.assertEqual(self.passfile._presave_fixup(uuid_hex, 5), crlf)
def _create_find_db(self):
entries = [{
3: "carte de crédit",
4: "username1",
5: "This is a note",
6: "password1",
13: "http://www.example.com"
}, {
2: "folder1",
3: "carte de credit",
4: "username1",
5: "anothernote",
6: "password1"
}, {
2: "level1group.level2group.level3group",
3: "level3entry",
4: "usernamelevel3",
6: "passwordlevel3",
13: "http://note.com"
}]
self.passfile.new_db('pasaffe')
for entry in entries:
uuid = self.passfile.new_entry()
for key in entry.keys():
self.passfile.records[uuid][key] = entry[key]
def test_update_find_results(self):
self._create_find_db()
self.passfile.update_find_results("")
self.assertEqual(self.passfile.find_results, [])
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "")
# Test field 3
self.passfile.update_find_results("level3entry")
self.assertEqual(len(self.passfile.find_results), 1)
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "level3entry")
# Test field 5
self.passfile.update_find_results("another")
self.assertEqual(len(self.passfile.find_results), 1)
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "another")
# Test field 13
self.passfile.update_find_results("example.com")
self.assertEqual(len(self.passfile.find_results), 1)
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "example.com")
# Test matching entries with accents
self.passfile.update_find_results("credit")
self.assertEqual(len(self.passfile.find_results), 2)
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "credit")
# Test specifying search term with accent
self.passfile.update_find_results("crédit")
self.assertEqual(len(self.passfile.find_results), 2)
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "crédit")
# Test force option
self.passfile.find_results = []
self.passfile.update_find_results("crédit")
self.assertEqual(len(self.passfile.find_results), 0)
self.passfile.update_find_results("crédit", True)
self.assertEqual(len(self.passfile.find_results), 2)
# Test clearing out values
self.passfile.update_find_results("")
self.assertEqual(self.passfile.find_results, [])
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "")
def test_get_next_find_result(self):
self._create_find_db()
self.assertEqual(self.passfile.get_next_find_result(), None)
self.assertEqual(self.passfile.get_next_find_result(True), None)
self.passfile.update_find_results("note")
self.assertEqual(len(self.passfile.find_results), 3)
self.assertEqual(self.passfile.find_results_index, None)
self.assertEqual(self.passfile.find_value, "note")
self.assertEqual(self.passfile.find_results_index, None)
uuid1 = self.passfile.get_next_find_result()
self.assertEqual(self.passfile.find_results_index, 0)
self.assertNotEqual(uuid1, None)
uuid2 = self.passfile.get_next_find_result()
self.assertEqual(self.passfile.find_results_index, 1)
self.assertNotEqual(uuid2, None)
self.assertNotEqual(uuid1, uuid2)
uuid3 = self.passfile.get_next_find_result()
self.assertEqual(self.passfile.find_results_index, 2)
self.assertNotEqual(uuid3, None)
self.assertNotEqual(uuid1, uuid3)
self.assertNotEqual(uuid2, uuid3)
# This should wrap around
uuid4 = self.passfile.get_next_find_result()
self.assertEqual(self.passfile.find_results_index, 0)
self.assertNotEqual(uuid4, None)
self.assertEqual(uuid1, uuid4)
# And now try backwards
uuid5 = self.passfile.get_next_find_result(True)
self.assertEqual(self.passfile.find_results_index, 2)
self.assertNotEqual(uuid5, None)
self.assertEqual(uuid3, uuid5)