def test_not_equal_on_not_equal_signature_data(self):
"""
Test that the inequality operator returns True when comparing two
sign response payloads with different signature_data.
"""
a = sign.SignResponsePayload(unique_identifier='a',
signature_data=b'\x01')
b = sign.SignResponsePayload(unique_identifier='a',
signature_data=b'\x02')
self.assertTrue(a != b)
self.assertTrue(b != a)
def test_equal_on_not_equal_unique_identifier(self):
"""
Test that the equality operator returns False when comparing two
sign response payloads with different unique_identifier.
"""
a = sign.SignResponsePayload(unique_identifier='a',
signature_data=b'\x01')
b = sign.SignResponsePayload(unique_identifier='b',
signature_data=b'\x01')
self.assertFalse(a == b)
self.assertFalse(b == a)
def test_not_equal_on_equal(self):
"""
Test that the inequality operator returns false when comparing two
equal sign response payloads.
"""
encoding = utils.BytearrayStream(self.full_encoding.buffer)
a = sign.SignResponsePayload()
b = sign.SignResponsePayload()
self.assertFalse(a != b)
self.assertFalse(b != a)
a.read(encoding)
b.read(self.full_encoding)
self.assertFalse(a != b)
self.assertFalse(b != a)
def test_read_invalid(self):
"""
Test that a ValueError gets raised when required Sign response
payload attributes are missing from the payload encoding.
"""
payload = sign.SignResponsePayload()
args = (self.empty_encoding, )
self.assertRaisesRegexp(
ValueError,
"invalid payload missing the unique identifier attribute",
payload.read, *args)
payload = sign.SignResponsePayload()
args = (self.incomplete_encoding, )
self.assertRaisesRegexp(
ValueError, "invalid payload missing the signature data attribute",
payload.read, *args)
def test_invalid_signature_data(self):
"""
Test that a TypeError is raised when an invalid value is used to set
the signature data of a Sign response payload.
"""
payload = sign.SignResponsePayload()
args = (payload, 'signature_data', 0)
self.assertRaisesRegexp(TypeError, "signature data must be bytes",
setattr, *args)
def test_init(self):
"""
Test that a Sign response payload can be constructed with no
arguments.
"""
payload = sign.SignResponsePayload()
self.assertEqual(None, payload.unique_identifier)
self.assertEqual(None, payload.signature_data)
def test_invalid_unique_identifier(self):
"""
Test that a TypeError is raised when an invalid value is used to set
the unique identifier of a Sign response payload.
"""
payload = sign.SignResponsePayload()
args = (payload, 'unique_identifier', 0)
self.assertRaisesRegex(TypeError, "unique identifier must be a string",
setattr, *args)
def test_not_equal_on_type_mismatch(self):
"""
Test that the inequality operator returns True when comparing a
sign response payload to a different type.
"""
a = sign.SignResponsePayload()
b = 'invalid'
self.assertTrue(a != b)
self.assertTrue(b != a)
def test_equal_on_type_mismatch(self):
"""
Test that the equality operator returns False when comparing a sign
response payload to another type.
"""
a = sign.SignResponsePayload()
b = 'invalid'
self.assertFalse(a == b)
self.assertFalse(b == a)
def test_write_invalid(self):
"""
Test that a ValueError gets raised when a required Sign response
payload attribute is missing when encoding the payload.
"""
payload = sign.SignResponsePayload()
stream = utils.BytearrayStream()
args = (stream, )
self.assertRaisesRegexp(
ValueError,
"invalid payload missing the unique identifier attribute",
payload.write, *args)
def test_init_with_args(self):
"""
Test that a Sign response payload can be constructed with valid
values.
"""
payload = sign.SignResponsePayload(
unique_identifier='00000000-1111-2222-3333-444444444444',
signature_data=b'\x01\x02\x03')
self.assertEqual('00000000-1111-2222-3333-444444444444',
payload.unique_identifier)
self.assertEqual(b'\x01\x02\x03', payload.signature_data)
def test_write(self):
"""
Test that a Sign response payload can be written to a data stream.
"""
payload = sign.SignResponsePayload(
unique_identifier='b4faee10-aa2a-4446-8ad4-0881f3422959',
signature_data=b'\x01\x02\x03\x04\x05\x06\x07\x08'
b'\x09\x10\x11\x12\x13\x14\x15\x16')
stream = utils.BytearrayStream()
payload.write(stream)
self.assertEqual(len(self.full_encoding), len(stream))
self.assertEqual(str(self.full_encoding), str(stream))
def test_str(self):
"""
Test that str can be applied to a sign response payload.
"""
payload = sign.SignResponsePayload(
unique_identifier='00000000-1111-2222-3333-444444444444',
signature_data=b'\x01\x02\x03')
expected = str({
'unique_identifier': '00000000-1111-2222-3333-444444444444',
'signature_data': b'\x01\x02\x03'
})
observed = str(payload)
self.assertEqual(expected, observed)
def test_repr(self):
"""
Test that repr can applied to a sign response payload.
"""
payload = sign.SignResponsePayload(
unique_identifier='00000000-1111-2222-3333-444444444444',
signature_data=b'\x01\x02\x03')
expected = (
"SignResponsePayload("
"unique_identifier='00000000-1111-2222-3333-444444444444', "
"signature_data=" + str(b'\x01\x02\x03') + ")")
observed = repr(payload)
self.assertEqual(expected, observed)
def test_read(self):
"""
Test that a Sign response payload can be read from a data stream.
"""
payload = sign.SignResponsePayload()
self.assertEqual(None, payload.unique_identifier)
self.assertEqual(None, payload.signature_data)
payload.read(self.full_encoding)
self.assertEqual('b4faee10-aa2a-4446-8ad4-0881f3422959',
payload.unique_identifier)
self.assertEqual(
b'\x01\x02\x03\x04\x05\x06\x07\x08'
b'\x09\x10\x11\x12\x13\x14\x15\x16', payload.signature_data)
def _create_sign_payload(self):
return sign.SignResponsePayload()
