def test_execute_valid_get(self): storage = KeepassDatabase(self._display, self._database_details_valid) actual = storage.execute(self._search_path_valid.search, check_mode=False, fail_silently=True) self.assertFalse(actual["changed"]) self.assertFalse(actual["failed"]) self.assertDictEqual(self._search_path_valid.search.__dict__, actual["result"]["search"]) self.assertDictEqual(self._database_entry, actual["result"]["outcome"]) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % self._database_details_valid["location"]), call.vvv("Keepass: keyfile found - %s" % self._database_details_valid["keyfile"]), call.v("Keepass: database opened - %s" % self._database_details_valid["location"]), call.vvv('Keepass: execute - %s' % [{ 'search': to_native(self._search_path_valid.search) }, { 'check_mode': 'False' }, { 'fail_silently': 'True' }]), call.vv("KeePass: entry found - %s" % self._search_path_valid.search) ])
def test_execute_valid_delete_entry(self): database_details_delete = self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))) storage = KeepassDatabase(self._display, database_details_delete) actual = storage.execute(self._delete_entry.search, check_mode=False, fail_silently=False) self.assertTrue(actual["changed"]) self.assertFalse(actual["failed"]) self.assertDictEqual(self._delete_entry.search.__dict__, actual["result"]["search"]) self.assertEqual(None, actual["result"]["outcome"]) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % database_details_delete["location"]), call.vvv("Keepass: keyfile found - %s" % database_details_delete["keyfile"]), call.v("Keepass: database opened - %s" % database_details_delete["location"]), call.vvv('Keepass: execute - %s' % [{ 'search': to_native(self._delete_entry.search) }, { 'check_mode': 'False' }, { 'fail_silently': 'False' }]), call.vv("KeePass: entry found - %s" % self._delete_entry.search), call.v("Keepass: database saved - %s" % database_details_delete["location"]) ])
def run(self, terms, variables=None, **kwargs): self.set_options(var_options=variables, direct=kwargs) check_mode = self.get_option("check_mode") fail_silently = self.get_option("fail_silently") storage = KeepassDatabase(display, self.get_option("database")) display.vvv("keepass: terms %s" % terms) return list( map( lambda term: storage.execute(Query(display, True, term).search, check_mode=check_mode, fail_silently=fail_silently), terms))
def test_execute_invalid_not_updatable_fail_silently(self): database_details_delete = dict(self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))), updatable=False) storage = KeepassDatabase(self._display, database_details_delete) actual = storage.execute(self._delete_entry.search, check_mode=False, fail_silently=True) self.assertFalse(actual["changed"]) self.assertTrue(actual["failed"]) self.assertDictEqual(self._delete_entry.search.__dict__, actual["result"]["search"]) self.assertTrue("Invalid query - database is not 'updatable'" in ( actual["result"]["outcome"]["error"])) self._display.assert_has_calls([])
def test_get_valid_property(self): storage = KeepassDatabase(self._display, self._database_details_valid) has_changed, actual_entry = storage.get(self._query_password.search, check_mode=False) self.assertFalse(has_changed) self.assertEqual(self._database_entry["password"], actual_entry["password"]) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % self._database_details_valid["location"]), call.vvv("Keepass: keyfile found - %s" % self._database_details_valid["keyfile"]), call.v("Keepass: database opened - %s" % self._database_details_valid["location"]), call.vv("KeePass: entry found - %s" % self._query_password.search) ])
def test__entry_upsert_invalid_post_when_exists_throw_error(self): database_details_upsert = self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))) storage = KeepassDatabase(self._display, database_details_upsert) self.assertRaises(AttributeError, storage._entry_upsert, self._post_path_invalid.search, False) self._display.assert_has_calls([])
def test__entry_find_invalid_by_path_no_error(self): storage = KeepassDatabase(self._display, self._database_details_valid) actual_entry = storage._entry_find(self._search_path_invalid.search, ref_uuid=None, not_found_throw=False) self.assertEqual(None, actual_entry) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % self._database_details_valid["location"]), call.vvv("Keepass: keyfile found - %s" % self._database_details_valid["keyfile"]), call.v("Keepass: database opened - %s" % self._database_details_valid["location"]), call.vv("KeePass: entry NOT found - %s" % self._search_path_invalid.search), ])
def test__save_valid(self): database_details_save = self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))) storage = KeepassDatabase(self._display, database_details_save) self.assertTrue(isinstance(storage._database, PyKeePass)) storage._save() self._display.assert_has_calls([ call.v(u"Keepass: database found - %s" % database_details_save["location"]), call.vvv(u"Keepass: keyfile found - %s" % database_details_save["keyfile"]), call.v(u"Keepass: database opened - %s" % database_details_save["location"]), call.v(u"Keepass: database saved - %s" % database_details_save["location"]) ])
def test__get_binary_b64_encoded(self): message = "hello world".encode("utf16") base64_encoded = base64.b64encode(message) actual = KeepassDatabase( self._display, self._database_details_valid)._get_binary(base64_encoded) self.assertEqual((message, True), actual)
def test__entry_upsert_valid_noop(self): database_details_upsert = self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))) storage = KeepassDatabase(self._display, database_details_upsert) has_changed, updated_entry = storage._entry_upsert( self._noop_path_valid.search, check_mode=False) self.assertFalse(has_changed) self.assertDictEqual(self._clone_entry, updated_entry) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % database_details_upsert["location"]), call.vvv("Keepass: keyfile found - %s" % database_details_upsert["keyfile"]), call.v("Keepass: database opened - %s" % database_details_upsert["location"]), call.vv("KeePass: entry found - %s" % self._noop_path_valid.search) ])
def test__entry_find_valid_by_path(self): storage = KeepassDatabase(self._display, self._database_details_valid) actual_entry = storage._entry_find(self._search_path_valid.search, ref_uuid=None, not_found_throw=True) self.assertDictEqual(self._database_entry, EntryDump(actual_entry).__dict__) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % self._database_details_valid["location"]), call.vvv("Keepass: keyfile found - %s" % self._database_details_valid["keyfile"]), call.v("Keepass: database opened - %s" % self._database_details_valid["location"]), call.vv("KeePass: entry found - %s" % self._search_path_valid.search), ])
def test_delete_valid_entry(self): database_details_delete = self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))) storage = KeepassDatabase(self._display, database_details_delete) has_changed, deleted_entry = storage.delete(self._delete_entry.search, check_mode=False) self.assertTrue(has_changed) self.assertEqual(None, deleted_entry) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % database_details_delete["location"]), call.vvv("Keepass: keyfile found - %s" % database_details_delete["keyfile"]), call.v("Keepass: database opened - %s" % database_details_delete["location"]), call.vv("KeePass: entry found - %s" % self._delete_entry.search), call.v("Keepass: database saved - %s" % database_details_delete["location"]) ])
def do_lookup(value): try: if not isinstance(value, dict) or value.get( "database", None) is None or value.get("lookup", None) is None: raise AttributeError( "must be a dictionary providing the following elements database (must a valid database description) and lookup" ) display.vvv("keepass: lookup %s" % value["lookup"]) outcome = KeepassDatabase(display, value["database"]).execute( Query(display, True, value["lookup"]).search, check_mode=False, fail_silently=False)["result"]["outcome"] return next(enumerate( outcome.values()))[1] if "?" in value["lookup"] else outcome except Exception as error: raise AnsibleFilterError( AnsibleError(message=to_native(error), orig_exc=error))
def test_get_valid_file(self): storage = KeepassDatabase(self._display, self._database_details_valid) has_changed, actual_entry = storage.get(self._query_file.search, check_mode=False) with open(self._database_details_valid["keyfile"], mode="rb") as file: self.assertFalse(has_changed) self.assertEqual( base64.b64encode(file.read()), actual_entry[os.path.basename( self._database_details_valid["keyfile"])]) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % self._database_details_valid["location"]), call.vvv("Keepass: keyfile found - %s" % self._database_details_valid["keyfile"]), call.v("Keepass: database opened - %s" % self._database_details_valid["location"]), call.vv("KeePass: entry found - %s" % self._query_file.search), call.vv("KeePass: found property/file on entry - %s" % self._query_file.search) ])
def test_execute_invalid_not_updatable_not_silently_throw(self): database_details_delete = dict(self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))), updatable=False) storage = KeepassDatabase(self._display, database_details_delete) self.assertRaises(AnsibleParserError, storage.execute, self._delete_entry.search, check_mode=False, fail_silently=False) self._display.assert_has_calls([])
def test__open_valid_details(self): storage = KeepassDatabase(self._display, self._database_details_valid) self.assertIsNotNone(storage._database) self.assertTrue(isinstance(storage._database, PyKeePass)) self._display.assert_has_calls([ call.v('Keepass: database found - %s' % self._database_details_valid["location"]), call.vvv('Keepass: keyfile found - %s' % self._database_details_valid["keyfile"]), call.v('Keepass: database opened - %s' % self._database_details_valid["location"]) ])
def test_get_invalid(self): storage = KeepassDatabase(self._display, self._database_details_valid) self.assertRaises(AttributeError, storage.get, self._query_invalid.search, False) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % self._database_details_valid["location"]), call.vvv("Keepass: keyfile found - %s" % self._database_details_valid["keyfile"]), call.v("Keepass: database opened - %s" % self._database_details_valid["location"]), call.vv("KeePass: entry found - %s" % self._query_invalid.search) ])
def test__entry_find_invalid_path_raise_error(self): storage = KeepassDatabase(self._display, self._database_details_valid) self.assertRaises(AnsibleError, storage._entry_find, self._search_path_invalid.search, None, True) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % self._database_details_valid["location"]), call.vvv("Keepass: keyfile found - %s" % self._database_details_valid["keyfile"]), call.v("Keepass: database opened - %s" % self._database_details_valid["location"]), call.vv("KeePass: entry NOT found - %s" % self._search_path_invalid.search) ])
def test_delete_valid_no_property_exists(self): database_details_delete = self._copy_database("temp_" + "".join( random.choices(string.ascii_uppercase + string.digits, k=16))) storage = KeepassDatabase(self._display, database_details_delete) self.assertRaises(AttributeError, storage.delete, self._delete_invalid_property.search, False) self._display.assert_has_calls([ call.v("Keepass: database found - %s" % database_details_delete["location"]), call.vvv("Keepass: keyfile found - %s" % database_details_delete["keyfile"]), call.v("Keepass: database opened - %s" % database_details_delete["location"]), call.vv("KeePass: entry found - %s" % self._delete_invalid_property.search) ])
def run(self, tmp=None, task_vars=None): super(ActionModule, self).run(tmp, task_vars) display.vvv("keepass: args - %s" % list(({ key: value } for key, value in self._task.args.items() if key != "database"))) if self._task.args.get("term", None) is not None and len( set(self._search_args).intersection(set( self._task.args.keys()))) > 0: raise AnsibleParserError( AnsibleError(u"'term' is mutually exclusive with %s" % self._search_args)) search = Query(display, False, self._task.args["term"]).search if self._task.args.get("term", None) is not None else \ Search(display=display, read_only=False, action=self._task.args.get("action", None), path=self._task.args.get("path", None), field=self._task.args.get("field", None), value=self._task.args.get("value", None), value_was_provided=self._task.args.get("value", None) is not None) return KeepassDatabase(display, self._task.args.get("database", None)).\ execute(search, self._task.args.get("check_mode", False), self._task.args.get("fail_silently", False))
def test__get_binary_plain_text(self): message = "hello world".encode("utf16") actual = KeepassDatabase( self._display, self._database_details_valid)._get_binary(message) self.assertEqual((bytes(message), False), actual)