def test_rotate(self):
# insert root
root_message = protocol.ClientMessage()
root_message.insert(None, 5, 'left')
server_message = self.s.receive(root_message)
# insert left child
insert_message = protocol.ClientMessage()
insert_message.insert(5, 3, 'left')
server_message_2 = self.s.receive(insert_message)
self.assertEqual(3, self.s.root.left.value)
self.assertEqual(None, self.s.root.right)
# insert a right child into unbalanced tree
# insert_message_2 = protocol.ClientMessage()
# insert_message_2.insert(3, 4, 'right')
# server_message_3 = self.s.receive(insert_message_2)
new_node = server.Server.OPE_Node(4)
new_node.parent = self.s.root.left
self.s.root.left.right = new_node
self.assertEqual(3, server.height(self.s.root))
self.assertEqual(2, server.subtree_size(self.s.root.left))
self.assertEqual(2, server.balance_factor(self.s.root))
server.left_rotate(self.s.root.left)
self.assertEqual(4, self.s.root.left.value)
self.assertEqual(3, self.s.root.left.left.value)
self.assertEqual(3, server.subtree_size(self.s.root))
server.right_rotate(self.s.root)
server.Server.update_root(self.s)
self.assertEqual(4, self.s.root.value)
self.assertEqual(5, self.s.root.right.value)
self.assertEqual(3, self.s.root.left.value)
def test_move_right(self):
root_message = protocol.ClientMessage()
root_message.insert(None, 5, 'left')
server_message = self.s.receive(root_message)
move_right_message = protocol.ClientMessage()
move_right_message.move_right(5)
server_message = self.s.receive(move_right_message)
self.assertEqual(None, server_message.ciphertext)
def test_get_root(self):
root_message = protocol.ClientMessage()
root_message.insert(None, 5, 'left')
server_message = self.s.receive(root_message)
get_root_message = protocol.ClientMessage()
get_root_message.get_root()
server_message = self.s.receive(get_root_message)
self.assertEqual(5, self.s.root.value)
self.assertEqual(5, server_message.ciphertext)
def test_move_left(self):
root_message = protocol.ClientMessage()
root_message.insert(None, 5, 'left')
server_message = self.s.receive(root_message)
insert_message = protocol.ClientMessage()
insert_message.insert(5, 3, 'left')
server_message_2 = self.s.receive(insert_message)
move_left_message = protocol.ClientMessage()
move_left_message.move_left(5)
server_message_3 = self.s.receive(move_left_message)
self.assertEqual(3, server_message_3.ciphertext)
def query(self, message):
if self.dcs_scheme:
message = self.dcs_scheme.encrypt(message)
ciphertext = self.encryption_scheme.encrypt(self.key, message)
client_message = protocol.ClientMessage()
client_message.query(ciphertext)
return self._send_client_message(client_message)
def setUp(self):
self.factory = communication_channel.CommunicationFactory()
self.server_channel = self.factory.build_for("server")
self.client_channel = self.factory.build_for("client")
#self.client = client.Client(self.client_channel)
self.client_message = protocol.ClientMessage()
self.client_message.get_root()
def test_query(self):
ciphertext = self.encryption_scheme.encrypt(self.key, self.message)
client_message = protocol.ClientMessage()
client_message.query(ciphertext)
self.assertIsInstance(client_message, protocol.ClientMessage)
self.assertEqual(client_message.message_type.__repr__(),
protocol.MessageType("query").__repr__())
def test_move_left(self):
ciphertext = self.encryption_scheme.encrypt(self.key, self.message)
client_message = protocol.ClientMessage()
client_message.move_left(ciphertext)
#TODO protocol.ClientMessage().move_left(ciphertext) doesn't work
self.assertIsInstance(client_message, protocol.ClientMessage)
self.assertEqual(client_message.message_type.__repr__(),
protocol.MessageType("move_left").__repr__())
def test_insert(self):
ciphertext = self.encryption_scheme.encrypt(self.key, self.message)
client_message = protocol.ClientMessage()
client_message.insert(ciphertext, None, "left")
self.assertIsInstance(client_message, protocol.ClientMessage)
self.assertIsNone(client_message.new_ciphertext)
self.assertEqual(client_message.insert_direction, "left")
self.assertEqual(client_message.message_type.__repr__(),
protocol.MessageType("insert").__repr__())
def _insert(self, current_ciphertext, new_ciphertext, direction):
if self.dcs_scheme:
current_ciphertext = self.dcs_scheme.encrypt(current_ciphertext)
new_ciphertext = self.dcs_scheme.encrypt(new_ciphertext)
print "Client insert, current_ciphertext=" + str(
current_ciphertext) + ", new_ciphertext:" + str(
new_ciphertext) + ", direction:" + str(direction)
client_message = protocol.ClientMessage()
client_message.insert(current_ciphertext, new_ciphertext, direction)
return self._send_client_message(client_message)
def test_insert_root(self):
root_message = protocol.ClientMessage()
root_message.insert(None, 5, 'left')
server_message = self.s.receive(root_message)
self.assertEqual(root_message.new_ciphertext,
server_message.ciphertext)
self.assertEqual(self.s.fake_ope_table,
{root_message.new_ciphertext: self.s.root})
self.assertEqual(
server.Server.OPE_Node(root_message.new_ciphertext).value,
self.s.root.value)
def _move_right(self, ciphertext):
if self.dcs_scheme:
ciphertext = self.dcs_scheme.encrypt(ciphertext)
client_message = protocol.ClientMessage()
client_message.move_right(ciphertext)
return self._send_client_message(client_message)
def _get_root(self):
client_message = protocol.ClientMessage()
client_message.get_root()
return self._send_client_message(client_message)
def test_get_root(self):
client_message = protocol.ClientMessage()
client_message.get_root()
self.assertIsInstance(client_message, protocol.ClientMessage)
self.assertEqual(client_message.message_type.__repr__(),
protocol.MessageType("get_root").__repr__())
def insert_test(self):
message = self.client._insert(1, 10, 'left')
test_message = protocol.ClientMessage()
test_message.insert(1, 10, 'left')
self.assertEqual(message, test_message)
def left_test(self):
message = self.client._move_left(10)
test_message = protocol.ClientMessage()
test_message.move_left(10)
self.assertEqual(message, test_message)
def root_test(self):
message = self.client._get_root()
test_message = protocol.ClientMessage()
test_message.get_root()
self.assertEqual(message, test_message)
