def test_expires(self):
"""
Ensure the expires argument is handled and checked appropriately.
* If it's not passed the expires metadata defaults to 0.0.
* It must be a number (int or float).
* It must be > 0
* The "expires" metadata must == timestamp + passed in expires arg.
"""
key = 'key'
value = 'value'
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY)
self.assertEqual(0.0, signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY,
'foo')
self.assertEqual(0.0, signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY, 123)
self.assertEqual(signed_item['timestamp'] + 123,
signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY,
123.456)
self.assertEqual(signed_item['timestamp'] + 123.456,
signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY, -1)
self.assertEqual(0.0, signed_item['expires'])
def test_expires(self):
"""
Ensure the expires argument is handled and checked appropriately.
* If it's not passed the expires metadata defaults to 0.0.
* It must be a number (int or float).
* It must be > 0
* The "expires" metadata must == timestamp + passed in expires arg.
"""
key = 'key'
value = 'value'
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY)
self.assertEqual(0.0, signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY,
'foo')
self.assertEqual(0.0, signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY,
123)
self.assertEqual(signed_item['timestamp'] + 123,
signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY,
123.456)
self.assertEqual(signed_item['timestamp'] + 123.456,
signed_item['expires'])
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY,
-1)
self.assertEqual(0.0, signed_item['expires'])
def test_modified_item(self):
"""
The content of the item does not match the hash / signature.
"""
signed_item = get_signed_item('key', 'value', PUBLIC_KEY, PRIVATE_KEY)
signed_item['public_key'] = BAD_PUBLIC_KEY
self.assertFalse(verify_item(signed_item))
def test_signed_item_is_verifiable(self):
"""
Check that the resulting item is able to be verified.
"""
signed_item = get_signed_item('key', 'value', PUBLIC_KEY,
PRIVATE_KEY)
self.assertTrue(verify_item(signed_item))
def test_modified_item(self):
"""
The content of the item does not match the hash / signature.
"""
signed_item = get_signed_item("key", "value", PUBLIC_KEY, PRIVATE_KEY)
signed_item["public_key"] = BAD_PUBLIC_KEY
self.assertFalse(verify_item(signed_item))
def setUp(self):
"""
Gives us some messages to play with.
"""
self.uuid = str(uuid4())
self.node = PUBLIC_KEY
self.recipient = PUBLIC_KEY
self.sender = PUBLIC_KEY
self.reply_port = 1908
self.value = 1.234
self.public_key = PUBLIC_KEY
self.name = 'a_human_readable_key_name'
self.key = construct_key(self.public_key, self.name)
signed_dict = get_signed_item(self.key, self.value, self.public_key,
PRIVATE_KEY, 1000)
self.version = get_version()
self.timestamp = signed_dict['timestamp']
self.expires = signed_dict['expires']
self.created_with = signed_dict['created_with']
self.signature = signed_dict['signature']
self.message = 'value'
self.seal = 'afakesealthatwillnotwork'
self.nodes = [[self.node, self.version, 'http://192.168.0.1:8080/'], ]
self.mock_message = Value(self.uuid, self.node, self.node,
self.reply_port, self.version, self.seal,
self.key, self.value, self.timestamp,
self.expires, self.created_with,
self.public_key, self.name, self.signature)
def test_does_not_modify_item(self):
"""
Ensure that the passed in item is itself not modified by the
verification process.
"""
signed_item = get_signed_item("key", "value", PUBLIC_KEY, PRIVATE_KEY)
self.assertTrue(verify_item(signed_item))
self.assertIn("signature", signed_item)
def test_does_not_modify_item(self):
"""
Ensure that the passed in item is itself not modified by the
verification process.
"""
signed_item = get_signed_item('key', 'value', PUBLIC_KEY, PRIVATE_KEY)
self.assertTrue(verify_item(signed_item))
self.assertIn('signature', signed_item)
def test_send_find_value_known(port, version, public_key, private_key):
"""
Ensures that a "findvalue" message for an existing key is sent to the
test node and the reply is checked.
"""
item = get_signed_item('item_name', "the item's value", public_key,
private_key)
signature = item['signature']
item['uuid'] = str(uuid4())
item['recipient'] = REMOTE_NODE_PUBLIC_KEY
item['sender'] = public_key
item['reply_port'] = 1908
item['version'] = version
msg = seal_message('store', item, private_key)
result = send_message(port, msg)
assert result.status_code == 200
item = {
'uuid': str(uuid.uuid4()),
'recipient': REMOTE_NODE_PUBLIC_KEY,
'sender': public_key,
'reply_port': 1908,
'version': version,
'key': construct_key(public_key, 'item_name'),
}
msg = seal_message('findvalue', item, private_key)
result = send_message(port, msg)
assert result.status_code == 200
reply = result.json()
assert reply['uuid'] == item['uuid']
assert reply['sender'] == REMOTE_NODE_PUBLIC_KEY
assert reply['recipient'] == public_key
assert reply['message'] == 'value'
assert reply['reply_port'] == port
assert reply['version'] == version
assert reply['name'] == 'item_name'
assert reply['value'] == "the item's value"
assert reply['key'] == construct_key(public_key, 'item_name')
assert reply['public_key'] == public_key
assert reply['signature'] == signature
assert reply['expires'] == 0.0
assert reply['created_with'] == version
assert isinstance(reply['timestamp'], float)
assert 'seal' in reply
assert check_seal(from_dict(reply))
def test_send_find_value_known(port, version, public_key, private_key):
"""
Ensures that a "findvalue" message for an existing key is sent to the
test node and the reply is checked.
"""
item = get_signed_item('item_name', "the item's value", public_key,
private_key)
signature = item['signature']
item['uuid'] = str(uuid4())
item['recipient'] = REMOTE_NODE_PUBLIC_KEY
item['sender'] = public_key
item['reply_port'] = 1908
item['version'] = version
msg = seal_message('store', item, private_key)
result = send_message(port, msg)
assert result.status_code == 200
item = {
'uuid': str(uuid.uuid4()),
'recipient': REMOTE_NODE_PUBLIC_KEY,
'sender': public_key,
'reply_port': 1908,
'version': version,
'key': construct_key(public_key, 'item_name'),
}
msg = seal_message('findvalue', item, private_key)
result = send_message(port, msg)
assert result.status_code == 200
reply = result.json()
assert reply['uuid'] == item['uuid']
assert reply['sender'] == REMOTE_NODE_PUBLIC_KEY
assert reply['recipient'] == public_key
assert reply['message'] == 'value'
assert reply['reply_port'] == port
assert reply['version'] == version
assert reply['name'] == 'item_name'
assert reply['value'] == "the item's value"
assert reply['key'] == construct_key(public_key, 'item_name')
assert reply['public_key'] == public_key
assert reply['signature'] == signature
assert reply['expires'] == 0.0
assert reply['created_with'] == version
assert isinstance(reply['timestamp'], float)
assert 'seal' in reply
assert check_seal(from_dict(reply))
def test_send_store(port, version, public_key, private_key):
"""
Sends and "store" message to the test node and check's the reply.
"""
item = get_signed_item('item_name', "the item's value", public_key,
private_key)
item['uuid'] = str(uuid4())
item['recipient'] = REMOTE_NODE_PUBLIC_KEY
item['sender'] = public_key
item['reply_port'] = 1908
item['version'] = version
msg = seal_message('store', item, private_key)
result = send_message(port, msg)
assert result.status_code == 200
reply = result.json()
assert reply['uuid'] == item['uuid']
assert reply['sender'] == REMOTE_NODE_PUBLIC_KEY
assert reply['recipient'] == public_key
assert reply['message'] == 'ok'
assert reply['reply_port'] == port
assert reply['version'] == version
assert 'seal' in reply
assert check_seal(from_dict(reply))
def test_send_store(port, version, public_key, private_key):
"""
Sends and "store" message to the test node and check's the reply.
"""
item = get_signed_item('item_name', "the item's value", public_key,
private_key)
item['uuid'] = str(uuid4())
item['recipient'] = REMOTE_NODE_PUBLIC_KEY
item['sender'] = public_key
item['reply_port'] = 1908
item['version'] = version
msg = seal_message('store', item, private_key)
result = send_message(port, msg)
assert result.status_code == 200
reply = result.json()
assert reply['uuid'] == item['uuid']
assert reply['sender'] == REMOTE_NODE_PUBLIC_KEY
assert reply['recipient'] == public_key
assert reply['message'] == 'ok'
assert reply['reply_port'] == port
assert reply['version'] == version
assert 'seal' in reply
assert check_seal(from_dict(reply))
def test_expected_metadata(self):
"""
Ensure the item (dict) returned from the function contains the
expected metadata.
"""
key = 'key'
value = 'value'
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY)
self.assertIn('timestamp', signed_item)
self.assertIsInstance(signed_item['timestamp'], float)
self.assertIn('expires', signed_item)
self.assertIsInstance(signed_item['expires'], float)
self.assertIn('created_with', signed_item)
self.assertEqual(signed_item['created_with'], get_version())
self.assertIn('public_key', signed_item)
self.assertEqual(signed_item['public_key'], PUBLIC_KEY)
self.assertIn('signature', signed_item)
self.assertIsInstance(signed_item['signature'], str)
self.assertIn('key', signed_item)
self.assertIsInstance(signed_item['key'], str)
self.assertEqual(signed_item['key'], construct_key(PUBLIC_KEY, key))
self.assertEqual(signed_item['name'], key)
self.assertEqual(signed_item['value'], value)
def test_expected_metadata(self):
"""
Ensure the item (dict) returned from the function contains the
expected metadata.
"""
key = 'key'
value = 'value'
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY)
self.assertIn('timestamp', signed_item)
self.assertIsInstance(signed_item['timestamp'], float)
self.assertIn('expires', signed_item)
self.assertIsInstance(signed_item['expires'], float)
self.assertIn('created_with', signed_item)
self.assertEqual(signed_item['created_with'], get_version())
self.assertIn('public_key', signed_item)
self.assertEqual(signed_item['public_key'], PUBLIC_KEY)
self.assertIn('signature', signed_item)
self.assertIsInstance(signed_item['signature'], str)
self.assertIn('key', signed_item)
self.assertIsInstance(signed_item['key'], str)
self.assertEqual(signed_item['key'], construct_key(PUBLIC_KEY, key))
self.assertEqual(signed_item['name'], key)
self.assertEqual(signed_item['value'], value)
def test_expected_metadata(self):
"""
Ensure the item (dict) returned from the function contains the
expected metadata.
"""
key = "key"
value = "value"
signed_item = get_signed_item(key, value, PUBLIC_KEY, PRIVATE_KEY)
self.assertIn("timestamp", signed_item)
self.assertIsInstance(signed_item["timestamp"], float)
self.assertIn("expires", signed_item)
self.assertIsInstance(signed_item["expires"], float)
self.assertIn("created_with", signed_item)
self.assertEqual(signed_item["created_with"], get_version())
self.assertIn("public_key", signed_item)
self.assertEqual(signed_item["public_key"], PUBLIC_KEY)
self.assertIn("signature", signed_item)
self.assertIsInstance(signed_item["signature"], str)
self.assertIn("key", signed_item)
self.assertIsInstance(signed_item["key"], str)
self.assertEqual(signed_item["key"], construct_key(PUBLIC_KEY, key))
self.assertEqual(signed_item["name"], key)
self.assertEqual(signed_item["value"], value)
def test_good_item(self):
"""
The good case should pass.
"""
signed_item = get_signed_item('key', 'value', PUBLIC_KEY, PRIVATE_KEY)
self.assertTrue(verify_item(signed_item))
def test_signed_item_is_verifiable(self):
"""
Check that the resulting item is able to be verified.
"""
signed_item = get_signed_item('key', 'value', PUBLIC_KEY, PRIVATE_KEY)
self.assertTrue(verify_item(signed_item))
def test_good_item(self):
"""
The good case should pass.
"""
signed_item = get_signed_item("key", "value", PUBLIC_KEY, PRIVATE_KEY)
self.assertTrue(verify_item(signed_item))
