def test_get_identities(self): """Test identity retrieval.""" db = ContentDB(tempfile.NamedTemporaryFile().name) id1 = dandelion.identity.generate() id2 = dandelion.identity.generate().public_identity() id3 = dandelion.identity.generate() db.add_identities([id1, id2, id3]) db.add_messages([Message("fu")]) _, idlist = db.get_identities() self.assertTrue(id1 in idlist) self.assertTrue(id2 in idlist) self.assertTrue(id3 in idlist) for id in idlist: self.assertFalse(id.rsa_key.is_private) self.assertFalse(id.dsa_key.is_private) _, idlist = db.get_identities(fingerprints=[id1.fingerprint, id2.fingerprint]) self.assertTrue(id1 in idlist) self.assertTrue(id2 in idlist) self.assertFalse(id3 in idlist) for id in idlist: self.assertFalse(id.rsa_key.is_private) self.assertFalse(id.dsa_key.is_private)
def test_identity_info_nick(self): """"Test getting and setting nickname""" db = ContentDB(tempfile.NamedTemporaryFile().name) id_a = dandelion.identity.generate() db.add_identities([id_a]) # Check for empty nicks self.assertIsNone(db.get_nick(b'1337')) self.assertIsNone(db.get_nick(id_a.fingerprint)) # Test setting a nick db.set_nick(id_a.fingerprint, "me") self.assertEqual(db.get_nick(id_a.fingerprint), "me") db.set_nick(id_a.fingerprint, "you") self.assertEqual(db.get_nick(id_a.fingerprint), "you") db.set_nick(id_a.fingerprint, None) self.assertIsNone(db.get_nick(id_a.fingerprint)) # Trying some bad input self.assertRaises(TypeError, db.get_nick, 0) self.assertRaises(TypeError, db.get_nick, '') self.assertRaises(TypeError, db.get_nick, None) self.assertRaises(ValueError, db.get_nick, b'') self.assertRaises(TypeError, db.set_nick, id_a.fingerprint, 0) self.assertRaises(TypeError, db.set_nick, id_a.fingerprint, b'') self.assertRaises(TypeError, db.set_nick, None, "qwerty") self.assertRaises(TypeError, db.set_nick, 0, "qwerty") self.assertRaises(TypeError, db.set_nick, '', "qwerty") self.assertRaises(ValueError, db.set_nick, b'', "qwerty")
def test_get_messages(self): """Test message retrieval.""" db = ContentDB(tempfile.NamedTemporaryFile().name) _, mlist = db.get_messages() self.assertEqual(mlist, []) id1 = dandelion.identity.generate() id2 = dandelion.identity.generate() m1 = Message('M1') m2 = Message('M2') m3 = dandelion.message.create('M3', 1337, id1, id2) db.add_identities([id1]) db.add_messages([m1, m2, m3]) _, mlist = db.get_messages() self.assertTrue(m1 in mlist) self.assertTrue(m2 in mlist) self.assertTrue(m3 in mlist) _, mlist = db.get_messages([m1.id, m3.id]) self.assertTrue(m1 in mlist) self.assertFalse(m2 in mlist) self.assertTrue(m3 in mlist)
def test_identity_info(self): """Test the IdentityInfo class""" db = ContentDB(tempfile.NamedTemporaryFile().name) id_a = dandelion.identity.generate() db.add_identities([id_a]) # Test creation id_info_a = IdentityInfo(db, id_a) self.assertEqual(id_info_a.db, db) self.assertEqual(id_info_a.id.fingerprint, id_a.fingerprint) self.assertIsNone(id_info_a.nick) self.assertTrue(id_info_a.is_private()) self.assertFalse(IdentityInfo(db, id_a.public_identity()).is_private()) # Test nick set/get id_info_a.nick = "me" self.assertEqual(id_info_a.nick, "me") id_info_a.nick = "you" self.assertEqual(id_info_a.nick, "you") id_info_a.nick = None self.assertIsNone(id_info_a.nick) # Test bad input self.assertRaises(TypeError, id_info_a.nick, 0) self.assertRaises(TypeError, id_info_a.nick, b'')
def test_identity_interface(self): """Test functions relating to storing and recovering identities.""" db = ContentDB(tempfile.NamedTemporaryFile().name) _, idlist = db.get_identities() self.assertEqual(idlist, []) id_a = dandelion.identity.generate() id_b = dandelion.identity.generate() first_id_list = [id_a, id_b] # Try to add junk self.assertRaises(TypeError, db.add_identities, None) self.assertRaises(TypeError, db.add_identities, 23) self.assertRaises(AttributeError, db.add_identities, [None]) # Add a message list self.assertEqual(db.identity_count, 0) db.add_identities(first_id_list) self.assertNotEqual(db.identity_count, None) self.assertEqual(db.identity_count, len(first_id_list)) self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [True, True]) # And for another message list? second_id_list = [dandelion.identity.generate(), id_a] self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [False, True]) # Adding the second message list db.add_identities(second_id_list) self.assertEqual(db.identity_count, 3) self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [True, True]) self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [True, True]) # Remove a list db.remove_identities(first_id_list) self.assertEqual(db.identity_count, 1) self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [False, False]) self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [True, False]) # Remove same message list db.remove_identities(first_id_list) self.assertEqual(db.identity_count, 1) self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [False, False]) self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [True, False]) # Remove all messages db.remove_identities() self.assertEqual(db.identity_count, 0) self.assertEqual([db.contains_identity(id.fingerprint) for id in first_id_list], [False, False]) self.assertEqual([db.contains_identity(id.fingerprint) for id in second_id_list], [False, False])
def test_basic_server_transaction(self): """Tests the server transaction protocol and logic""" db = ContentDB(tempfile.NamedTemporaryFile().name) db.add_identities([dandelion.identity.generate(), dandelion.identity.generate()]) tc = db.add_messages([Message("fubar"), Message("foo"), Message("bar")]) with TestServerHelper() as server_helper, TestClientHelper() as client_helper: srv_transaction = ServerTransaction(server_helper.sock, db) test_client = SocketTransaction(client_helper.sock, b"\n") """Run the server transaction in a separate thread to allow client access""" thread = threading.Thread(target=srv_transaction.process) thread.start() """Check greeting from server""" rcv = test_client._read() self.assertEqual(rcv, dandelion.protocol.create_greeting_message(db.id).encode()) """Check response to mdgid list req""" test_client._write(dandelion.protocol.create_message_id_list_request(tc).encode()) rcv = test_client._read() self.assertEqual(rcv, dandelion.protocol.create_message_id_list(tc, None).encode()) """Check response to identityid list req""" test_client._write(dandelion.protocol.create_identity_id_list_request(tc).encode()) rcv = test_client._read() self.assertEqual(rcv, dandelion.protocol.create_identity_id_list(tc, None).encode()) """Check response to mdg req""" test_client._write( dandelion.protocol.create_message_list_request([msg.id for msg in db.get_messages()[1]]).encode() ) rcv = test_client._read() self.assertEqual(rcv, dandelion.protocol.create_message_list(db.get_messages()[1]).encode()) """Check response to identity req""" test_client._write( dandelion.protocol.create_identity_list_request( [id.fingerprint for id in db.get_identities()[1]] ).encode() ) rcv = test_client._read() self.assertEqual(rcv, dandelion.protocol.create_identity_list(db.get_identities()[1]).encode()) """Wait for server (will time out if no requests)""" thread.join(2 * TIMEOUT)
def test_client_server_transaction_partial_sync(self): """Tests the whole, client driven transaction protocol and logic""" client_db = ContentDB(tempfile.NamedTemporaryFile().name) server_db = ContentDB(tempfile.NamedTemporaryFile().name) id1 = dandelion.identity.generate() id2 = dandelion.identity.generate() client_db.add_identities([id1]) server_db.add_identities([id1, id2]) client_db.add_messages([Message("fubar")]) server_db.add_messages([Message("fubar"), Message("foo"), Message("bar")]) self.assertEqual(client_db.identity_count, 1) self.assertEqual(server_db.identity_count, 2) self.assertEqual(client_db.message_count, 1) self.assertEqual(server_db.message_count, 3) with TestServerHelper() as server_helper, TestClientHelper() as client_helper: client_transaction = ClientTransaction(client_helper.sock, client_db) server_transaction = ServerTransaction(server_helper.sock, server_db) """Run the client transactions asynchronously""" server_thread = threading.Thread(target=server_transaction.process) client_thread = threading.Thread(target=client_transaction.process) server_thread.start() client_thread.start() """Wait for client to hang up""" client_thread.join(1) # One sec should be plenty server_thread.join(2 * TIMEOUT) """Make sure the client has updated the db""" self.assertEqual(client_db.identity_count, 2) self.assertEqual(server_db.identity_count, 2) self.assertEqual(client_db.message_count, 3) self.assertEqual(server_db.message_count, 3) self.assertEqual( len([srvmsg for srvmsg in server_db.get_messages()[1] if srvmsg not in client_db.get_messages()[1]]), 0 ) self.assertEqual( len([srvids for srvids in server_db.get_identities()[1] if srvids not in client_db.get_identities()[1]]), 0 )
def test_time_cookies(self): """Test the data base time cookies (revision) functionality.""" db = ContentDB(tempfile.NamedTemporaryFile().name) # Adding a message first_msg = Message('A Single Message') first_cookie = db.add_messages([first_msg]) self.assertNotEqual(first_cookie, None) self.assertTrue(isinstance(first_cookie, bytes)) self.assertTrue((db.get_last_time_cookie(None) is None) or (db.get_last_time_cookie(None) == first_cookie)) # Same message again self.assertEqual(first_cookie, db.add_messages([first_msg])) # New message, new cookie id1 = dandelion.identity.generate() id2 = dandelion.identity.generate() second_msg = dandelion.message.create('Another Single Message', sender=id1, receiver=id2) second_cookie = db.add_messages([second_msg]) self.assertNotEqual(second_cookie, None) self.assertNotEqual(second_cookie, first_cookie) self.assertTrue((db.get_last_time_cookie(None) is None) or (db.get_last_time_cookie(None) == second_cookie)) # Since first should only be second tc, some_messages = db.get_messages(time_cookie=first_cookie) self.assertNotEqual(some_messages, None) self.assertEqual(tc, second_cookie) self.assertEqual(len(some_messages), 1) self.assertEqual(some_messages[0], second_msg) # Nothing new since last message was added tc, last_messages = db.get_messages(time_cookie=second_cookie) self.assertNotEqual(last_messages, None) self.assertEqual(len(last_messages), 0) self.assertEqual(tc, second_cookie) # Same id gives same tc self.assertEqual(second_cookie, db.add_messages([first_msg])) # New identity, new cookie identity = dandelion.identity.generate() third_cookie = db.add_identities([identity]) self.assertNotEqual(third_cookie, None) self.assertNotEqual(third_cookie, second_cookie) self.assertTrue(db.get_last_time_cookie() == third_cookie) # Trying some bad input self.assertRaises(TypeError, db.get_messages, [], 0) self.assertRaises(TypeError, db.get_messages, [], '') self.assertRaises(TypeError, db.get_messages, [], 'fubar') self.assertRaises(ValueError, db.get_messages, [], b'') self.assertRaises(ValueError, db.get_messages, [], b'1337')
def test_basic_client_transaction(self): """Tests the client transaction protocol and logic""" client_db = ContentDB(tempfile.NamedTemporaryFile().name) srv_db = ContentDB(tempfile.NamedTemporaryFile().name) self.assertEqual(client_db.message_count, 0) srv_db.add_identities([dandelion.identity.generate(), dandelion.identity.generate()]) tc = srv_db.add_messages([Message("fubar"), Message("foo"), Message("bar")]) self.assertEqual(client_db.message_count, 0) self.assertEqual(client_db.identity_count, 0) self.assertEqual(srv_db.message_count, 3) self.assertEqual(srv_db.identity_count, 2) with TestServerHelper() as server_helper, TestClientHelper() as client_helper: client_transaction = ClientTransaction(client_helper.sock, client_db) srv_sock = SocketTransaction(server_helper.sock, b"\n") """Run the client transaction in a separate thread""" thread = threading.Thread(target=client_transaction.process) thread.start() """Send a greeting (should be req. by client)""" srv_sock._write(dandelion.protocol.create_greeting_message(srv_db.id).encode()) """Reading msg id list request""" rcv = srv_sock._read() self.assertEqual(rcv, dandelion.protocol.create_message_id_list_request().encode()) """Sending the msg id list""" srv_sock._write(dandelion.protocol.create_message_id_list(tc, srv_db.get_messages()[1]).encode()) """Reading msg list request""" rcv = srv_sock._read() expected_msgs = ( dandelion.protocol.create_message_list_request([msg.id for msg in srv_db.get_messages()[1]]) .split(" ")[1][:-1] .split(";") ) for msg in expected_msgs: self.assertNotEqual(rcv.find(msg.encode()), -1) """Sending the msg id list""" srv_sock._write(dandelion.protocol.create_message_list(srv_db.get_messages()[1]).encode()) """Reading identity id list request""" rcv = srv_sock._read() self.assertEqual(rcv, dandelion.protocol.create_identity_id_list_request().encode()) """Sending the identity id list""" srv_sock._write(dandelion.protocol.create_identity_id_list(tc, srv_db.get_identities()[1]).encode()) """Reading identity list request""" rcv = srv_sock._read() expected_ids = ( dandelion.protocol.create_identity_list_request([id.fingerprint for id in srv_db.get_identities()[1]]) .split(" ")[1][:-1] .split(";") ) for id in expected_ids: self.assertNotEqual(rcv.find(id.encode()), -1) """Sending the msg id list""" srv_sock._write(dandelion.protocol.create_identity_list(srv_db.get_identities()[1]).encode()) """Wait for client to hang up""" thread.join(2 * TIMEOUT) """Make sure the client has updated the db""" self.assertEqual(client_db.message_count, 3) self.assertEqual(srv_db.message_count, 3) self.assertEqual( len([srvmsg for srvmsg in srv_db.get_messages()[1] if srvmsg not in client_db.get_messages()[1]]), 0 )