def test_equal_on_not_equal_asynchronous_correlation_value(self):
"""
Test that the equality operator returns False when comparing two Cancel
response payloads with different asynchronous correlation values.
"""
a = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\xaa')
b = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\xbb')
self.assertFalse(a == b)
self.assertFalse(b == a)
def test_not_equal_on_not_equal_cancellation_result(self):
"""
Test that the inequality operator returns True when comparing two
Cancel response payloads with different cancellation results.
"""
a = payloads.CancelResponsePayload(
cancellation_result=enums.CancellationResult.FAILED)
b = payloads.CancelResponsePayload(
cancellation_result=enums.CancellationResult.COMPLETED)
self.assertTrue(a != b)
self.assertTrue(b != a)
def test_not_equal_on_type_mismatch(self):
"""
Test that the inequality operator returns True when comparing two
Cancel response payloads with different types.
"""
a = payloads.CancelResponsePayload()
b = 'invalid'
self.assertTrue(a != b)
self.assertTrue(b != a)
def test_not_equal_on_equal(self):
"""
Test that the inequality operator returns False when comparing two
Cancel response payloads with the same data.
"""
a = payloads.CancelResponsePayload()
b = payloads.CancelResponsePayload()
self.assertFalse(a != b)
self.assertFalse(b != a)
a = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\x49\xa1\xca\x88',
cancellation_result=enums.CancellationResult.COMPLETED)
b = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\x49\xa1\xca\x88',
cancellation_result=enums.CancellationResult.COMPLETED)
self.assertFalse(a != b)
self.assertFalse(b != a)
def test_write_empty(self):
"""
Test that an empty Cancel response payload can be written to a data
stream.
"""
payload = payloads.CancelResponsePayload()
stream = utils.BytearrayStream()
payload.write(stream)
self.assertEqual(len(self.empty_encoding), len(stream))
self.assertEqual(str(self.empty_encoding), str(stream))
def test_init_with_args(self):
"""
Test that a Cancel response payload can be constructed with valid
values.
"""
payload = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\x01',
cancellation_result=enums.CancellationResult.FAILED)
self.assertEqual(b'\x01', payload.asynchronous_correlation_value)
self.assertEqual(enums.CancellationResult.FAILED,
payload.cancellation_result)
def test_write(self):
"""
Test that a Cancel response payload can be written to a data stream.
"""
payload = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\x58\x3B\x00\x36\xC1\xA2\xDD\x01',
cancellation_result=enums.CancellationResult.CANCELED)
stream = utils.BytearrayStream()
payload.write(stream)
self.assertEqual(len(self.full_encoding), len(stream))
self.assertEqual(str(self.full_encoding), str(stream))
def test_repr(self):
"""
Test that repr can be applied to a Cancel response payload.
"""
payload = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\xaa',
cancellation_result=enums.CancellationResult.UNABLE_TO_CANCEL)
expected = ("CancelResponsePayload("
"asynchronous_correlation_value=" + str(b'\xaa') + ", "
"cancellation_result=" +
str(enums.CancellationResult.UNABLE_TO_CANCEL) + ")")
observed = repr(payload)
self.assertEqual(expected, observed)
def test_read_empty(self):
"""
Test that an Cancel response payload can be read from an empty data
stream.
"""
payload = payloads.CancelResponsePayload()
self.assertEqual(None, payload.asynchronous_correlation_value)
self.assertEqual(None, payload.cancellation_result)
payload.read(self.empty_encoding)
self.assertEqual(None, payload.asynchronous_correlation_value)
self.assertEqual(None, payload.cancellation_result)
def test_read(self):
"""
Test that a Cancel response payload can be read from a data stream.
"""
payload = payloads.CancelResponsePayload()
self.assertEqual(None, payload.asynchronous_correlation_value)
self.assertEqual(None, payload.cancellation_result)
payload.read(self.full_encoding)
self.assertEqual(b'\x58\x3B\x00\x36\xC1\xA2\xDD\x01',
payload.asynchronous_correlation_value)
self.assertEqual(enums.CancellationResult.CANCELED,
payload.cancellation_result)
def test_invalid_asynchronous_correlation_value(self):
"""
Test that a TypeError is raised when an invalid value is used to set
the asynchronous correlation value of an Cancel response payload.
"""
kwargs = {'asynchronous_correlation_value': 0}
self.assertRaisesRegex(
TypeError, "Asynchronous correlation value must be bytes.",
payloads.CancelResponsePayload, **kwargs)
payload = payloads.CancelResponsePayload()
args = (payload, 'asynchronous_correlation_value', 0)
self.assertRaisesRegex(
TypeError, "Asynchronous correlation value must be bytes.",
setattr, *args)
def test_str(self):
"""
Test that str can be applied to a Cancel response payload.
"""
payload = payloads.CancelResponsePayload(
asynchronous_correlation_value=b'\xaa',
cancellation_result=enums.CancellationResult.UNAVAILABLE
)
expected = str({
'asynchronous_correlation_value': b'\xaa',
'cancellation_result': enums.CancellationResult.UNAVAILABLE
})
observed = str(payload)
self.assertEqual(expected, observed)
def test_invalid_cancellation_result(self):
"""
Test that a TypeError is raised when an invalid value is used to set
the cancellation result of an Cancel response payload.
"""
kwargs = {'cancellation_result': 'invalid'}
self.assertRaisesRegex(
TypeError,
"Cancellation result must be a CancellationResult enumeration.",
payloads.CancelResponsePayload, **kwargs)
payload = payloads.CancelResponsePayload()
args = (payload, 'cancellation_result', 'invalid')
self.assertRaisesRegex(
TypeError,
"Cancellation result must be a CancellationResult enumeration.",
setattr, *args)
