def test_hello_version(self, v_mock):
msg = message.Hello()
self.assertEqual(msg._version, v_mock)
msg = message.Hello(deserialized=True, header=message.Hello().header)
self.assertFalse(hasattr(msg, '_version'))
version_kwarg = object()
msg_kwarg = message.Hello(_version=version_kwarg)
self.assertEqual(msg_kwarg._version, version_kwarg)
version_slot = object()
msg_slot = message.Hello(slots=[
('_version', version_slot),
], )
# Slots with '_' should be ignored
self.assertEqual(msg_slot._version, v_mock)
def test_deserialize_verify_sender(self):
msg = message.Hello()
data = golem_messages.dump(msg, self.ecc.raw_privkey, None)
msg_deserialized = message.base.Message.deserialize(
data, lambda d: d, sender_public_key=self.ecc.raw_pubkey)
self.assertEqual(msg, msg_deserialized)
def test_kwarg_and_slot(self):
node_name_kwarg = 'Tuż nad Bugiem, z lewej strony,'
node_name_slot = 'Stoi wielki bór zielony.'
msg = message.Hello(
node_name=node_name_kwarg,
slots=[('node_name', node_name_slot), ],
)
self.assertEqual(msg.node_name, node_name_slot)
def test_deserialize_verify_sender_fails(self):
ecc2 = golem_messages.ECCx(None)
msg = message.Hello()
data = golem_messages.dump(msg, self.ecc.raw_privkey, None)
with self.assertRaises(exceptions.InvalidSignature):
message.base.Message.deserialize(data,
lambda d: d,
sender_public_key=ecc2.raw_pubkey)
def test_default_slots(self):
"""Slots initialization to None"""
msg = message.Hello()
for key in msg.__slots__:
if key in message.Message.__slots__:
continue
if key.startswith('_'):
continue
self.assertIsNone(getattr(msg, key))
def test_hello_version_verify(self, v_mock):
msg = message.Hello()
serialized = golem_messages.dump(
msg,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
golem_messages.load(
serialized,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
v_mock.assert_called_once_with(golem_messages.__version__)
def test_verify_updated_header(self):
msg = message.Hello()
self.add_sig(msg)
msg2 = factories.helpers.clone_message(
msg,
override_header=datastructures.MessageHeader(
msg.TYPE,
msg.timestamp + 667,
msg.encrypted,
))
with self.assertRaises(exceptions.InvalidSignature):
msg2.verify_signature(self.keys.raw_pubkey)
def test_hello_version_signature(self):
msg = message.Hello()
serialized = golem_messages.dump(
msg,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
msg = golem_messages.load(
serialized,
self.ecc.raw_privkey,
self.ecc.raw_pubkey,
)
msg._version = 'haxior'
with self.assertRaises(exceptions.InvalidSignature):
self.ecc.verify(msg.sig, msg.get_short_hash())
def test_timestamp_and_timezones(self, *_):
epoch_t = 1475238345
def set_tz(tz):
os.environ['TZ'] = tz
try:
time.tzset()
except AttributeError:
raise unittest.SkipTest("tzset required")
set_tz('Europe/Warsaw')
warsaw_time = time.localtime(epoch_t)
msg_pre = message.Hello(header=datastructures.MessageHeader(
message.Hello.TYPE,
epoch_t,
False,
))
data = shortcuts.dump(msg_pre, None, None)
set_tz('US/Eastern')
msg_post = shortcuts.load(data, None, None)
newyork_time = time.localtime(msg_post.timestamp)
self.assertNotEqual(warsaw_time, newyork_time)
self.assertEqual(time.gmtime(epoch_t), time.gmtime(msg_post.timestamp))
def test_hello_version_equality(self, eq_mock):
eq_mock.return_value = True
msg1 = message.Hello()
msg2 = message.Hello()
self.assertEqual(msg1, msg2)
eq_mock.assert_called_once_with(msg2)
def test_verify_cloned(self):
msg = message.Hello()
self.add_sig(msg)
msg2 = factories.helpers.clone_message(msg)
self.assertTrue(msg2.verify_signature(self.keys.raw_pubkey))
def test_verify_different(self):
msg = message.Hello()
self.add_sig(msg)
with self.assertRaises(exceptions.InvalidSignature):
msg.verify_signature(self.keys2.raw_pubkey)
def test_verify_nosig(self):
msg = message.Hello()
self.assertIsNone(msg.sig)
with self.assertRaises(exceptions.InvalidSignature):
msg.verify_signature(self.keys.raw_pubkey)
def test_verify(self):
msg = message.Hello()
self.add_sig(msg)
self.assertTrue(msg.verify_signature(self.keys.raw_pubkey))
def test_slot(self):
node_name = 'Tuż nad Bugiem, z lewej strony,'
msg = message.Hello(slots=[('node_name', node_name), ])
self.assertEqual(msg.node_name, node_name)
def test_hello_version_inequality(self, eq_mock):
msg1 = message.Hello()
msg2 = message.Hello()
msg2._version = 'haxior'
self.assertNotEqual(msg1, msg2)
eq_mock.assert_not_called()
def test_kwarg(self):
node_name = 'Tuż nad Bugiem, z lewej strony,'
msg = message.Hello(node_name=node_name)
self.assertEqual(msg.node_name, node_name)
