def test_equal_on_not_equal(self):
"""
Test that the equality operator returns False when comparing two
Intervals with different values.
"""
a = primitives.Interval(1)
b = primitives.Interval(2)
self.assertFalse(a == b)
self.assertFalse(b == a)
def test_equal_on_equal_and_empty(self):
"""
Test that the equality operator returns True when comparing two
Intervals.
"""
a = primitives.Interval()
b = primitives.Interval()
self.assertTrue(a == b)
self.assertTrue(b == a)
def test_not_equal_on_equal_and_empty(self):
"""
Test that the inequality operator returns False when comparing
two Intervals.
"""
a = primitives.Interval()
b = primitives.Interval()
self.assertFalse(a != b)
self.assertFalse(b != a)
def test_not_equal_on_not_equal(self):
"""
Test that the inequality operator returns True when comparing two
Intervals with different values.
"""
a = primitives.Interval(1)
b = primitives.Interval(2)
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 Intervals with the same values.
"""
a = primitives.Interval(1)
b = primitives.Interval(1)
self.assertFalse(a != b)
self.assertFalse(b != a)
def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):
"""
Read the data encoding the Rekey request payload and decode it into
its constituent parts.
Args:
input_stream (stream): A data stream containing encoded object
data, supporting a read method; usually a BytearrayStream
object.
kmip_version (KMIPVersion): An enumeration defining the KMIP
version with which the object will be decoded. Optional,
defaults to KMIP 1.0.
"""
super(RekeyRequestPayload, self).read(input_stream,
kmip_version=kmip_version)
local_stream = utils.BytearrayStream(input_stream.read(self.length))
if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):
self._unique_identifier = primitives.TextString(
tag=enums.Tags.UNIQUE_IDENTIFIER)
self._unique_identifier.read(local_stream,
kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.OFFSET, local_stream):
self._offset = primitives.Interval(tag=enums.Tags.OFFSET)
self._offset.read(local_stream, kmip_version=kmip_version)
if self.is_tag_next(enums.Tags.TEMPLATE_ATTRIBUTE, local_stream):
self._template_attribute = objects.TemplateAttribute()
self._template_attribute.read(local_stream,
kmip_version=kmip_version)
self.is_oversized(local_stream)
def read(self, input_stream):
"""
Read the data encoding the Check response payload and decode it into
its constituent parts.
Args:
input_stream (stream): A data stream containing encoded object
data, supporting a read method; usually a BytearrayStream
object.
Raises:
ValueError: Raised if the data attribute is missing from the
encoded payload.
"""
super(CheckResponsePayload, self).read(input_stream)
local_stream = utils.BytearrayStream(input_stream.read(self.length))
if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):
self._unique_identifier = primitives.TextString(
tag=enums.Tags.UNIQUE_IDENTIFIER)
self._unique_identifier.read(local_stream)
if self.is_tag_next(enums.Tags.USAGE_LIMITS_COUNT, local_stream):
self._usage_limits_count = primitives.LongInteger(
tag=enums.Tags.USAGE_LIMITS_COUNT)
self._usage_limits_count.read(local_stream)
if self.is_tag_next(enums.Tags.CRYPTOGRAPHIC_USAGE_MASK, local_stream):
self._cryptographic_usage_mask = primitives.Integer(
tag=enums.Tags.CRYPTOGRAPHIC_USAGE_MASK)
self._cryptographic_usage_mask.read(local_stream)
if self.is_tag_next(enums.Tags.LEASE_TIME, local_stream):
self._lease_time = primitives.Interval(tag=enums.Tags.LEASE_TIME)
self._lease_time.read(local_stream)
self.is_oversized(local_stream)
def read(self, input_stream):
"""
Read the data encoding the ObtainLease response payload and decode it
into its constituent parts.
Args:
input_stream (stream): A data stream containing encoded object
data, supporting a read method; usually a BytearrayStream
object.
Raises:
ValueError: Raised if the data attribute is missing from the
encoded payload.
"""
super(ObtainLeaseResponsePayload, self).read(input_stream)
local_stream = utils.BytearrayStream(input_stream.read(self.length))
if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):
self._unique_identifier = primitives.TextString(
tag=enums.Tags.UNIQUE_IDENTIFIER)
self._unique_identifier.read(local_stream)
if self.is_tag_next(enums.Tags.LEASE_TIME, local_stream):
self._lease_time = primitives.Interval(tag=enums.Tags.LEASE_TIME)
self._lease_time.read(local_stream)
if self.is_tag_next(enums.Tags.LAST_CHANGE_DATE, local_stream):
self._last_change_date = primitives.DateTime(
tag=enums.Tags.LAST_CHANGE_DATE)
self._last_change_date.read(local_stream)
self.is_oversized(local_stream)
def read(self, input_stream):
"""
Read the data encoding the Rekey request payload and decode it into
its constituent parts.
Args:
input_stream (stream): A data stream containing encoded object
data, supporting a read method; usually a BytearrayStream
object.
"""
super(RekeyRequestPayload, self).read(input_stream)
local_stream = utils.BytearrayStream(input_stream.read(self.length))
if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):
self._unique_identifier = primitives.TextString(
tag=enums.Tags.UNIQUE_IDENTIFIER)
self._unique_identifier.read(local_stream)
if self.is_tag_next(enums.Tags.OFFSET, local_stream):
self._offset = primitives.Interval(tag=enums.Tags.OFFSET)
self._offset.read(local_stream)
if self.is_tag_next(enums.Tags.TEMPLATE_ATTRIBUTE, local_stream):
self._template_attribute = objects.TemplateAttribute()
self._template_attribute.read(local_stream)
self.is_oversized(local_stream)
def lease_time(self, value):
if value is None:
self._lease_time = None
elif isinstance(value, six.integer_types):
self._lease_time = primitives.Interval(value=value,
tag=enums.Tags.LEASE_TIME)
else:
raise TypeError("Lease time must be an integer.")
def offset(self, value):
if value is None:
self._offset = None
elif isinstance(value, six.integer_types):
self._offset = primitives.Interval(value=value,
tag=enums.Tags.OFFSET)
else:
raise TypeError("Offset must be an integer.")
def test_read(self):
"""
Test that an Interval can be read from a byte stream.
"""
stream = utils.BytearrayStream(self.encoding)
interval = primitives.Interval()
interval.read(stream)
self.assertEqual(self.value, interval.value)
def test_read_on_invalid_padding(self):
"""
Test that an InvalidPaddingBytes exception is thrown when attempting
to decode an Interval with invalid padding bytes.
"""
stream = utils.BytearrayStream(self.encoding_bad_padding)
interval = primitives.Interval()
self.assertRaises(exceptions.InvalidPaddingBytes, interval.read,
stream)
def test_read_on_invalid_length(self):
"""
Test that an InvalidPrimitiveLength exception is thrown when attempting
to decode an Interval with an invalid length.
"""
stream = utils.BytearrayStream(self.encoding_bad_length)
interval = primitives.Interval()
self.assertRaises(exceptions.InvalidPrimitiveLength, interval.read,
stream)
def test_repr(self):
"""
Test that the representation of a Interval is formatted properly.
"""
long_int = primitives.Interval()
value = "value={0}".format(long_int.value)
tag = "tag={0}".format(long_int.tag)
self.assertEqual("Interval({0}, {1})".format(value, tag),
repr(long_int))
def test_not_equal_on_type_mismatch(self):
"""
Test that the inequality operator returns True when comparing a
Interval to a non-Interval object.
"""
a = primitives.Interval()
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
Interval to a non-Interval object.
"""
a = primitives.Interval()
b = 'invalid'
self.assertFalse(a == b)
self.assertFalse(b == a)
def test_write(self):
"""
Test that an Interval can be written to a byte stream.
"""
stream = utils.BytearrayStream()
interval = primitives.Interval(self.value)
interval.write(stream)
result = stream.read()
self.assertEqual(len(self.encoding), len(result))
self.assertEqual(self.encoding, result)
def test_init_unset(self):
"""
Test that an Interval can be instantiated with no input.
"""
interval = primitives.Interval()
self.assertEqual(0, interval.value)
def test_str(self):
"""
Test that the string representation of a Interval is formatted
properly.
"""
self.assertEqual("0", str(primitives.Interval()))
def create_attribute_value(self, name, value):
# Switch on the name of the attribute
if name is enums.AttributeType.UNIQUE_IDENTIFIER:
return attributes.UniqueIdentifier(value)
elif name is enums.AttributeType.NAME:
return self._create_name(value)
elif name is enums.AttributeType.OBJECT_TYPE:
return attributes.ObjectType(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM:
return attributes.CryptographicAlgorithm(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_LENGTH:
return self._create_cryptographic_length(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_PARAMETERS:
return self._create_cryptographic_parameters(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_DOMAIN_PARAMETERS:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_TYPE:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_LENGTH:
return primitives.Integer(value, enums.Tags.CERTIFICATE_LENGTH)
elif name is enums.AttributeType.X_509_CERTIFICATE_IDENTIFIER:
raise NotImplementedError()
elif name is enums.AttributeType.X_509_CERTIFICATE_SUBJECT:
raise NotImplementedError()
elif name is enums.AttributeType.X_509_CERTIFICATE_ISSUER:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_IDENTIFIER:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_SUBJECT:
raise NotImplementedError()
elif name is enums.AttributeType.CERTIFICATE_ISSUER:
raise NotImplementedError()
elif name is enums.AttributeType.DIGITAL_SIGNATURE_ALGORITHM:
raise NotImplementedError()
elif name is enums.AttributeType.DIGEST:
return attributes.Digest()
elif name is enums.AttributeType.OPERATION_POLICY_NAME:
return attributes.OperationPolicyName(value)
elif name is enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK:
return self._create_cryptographic_usage_mask(value)
elif name is enums.AttributeType.LEASE_TIME:
return primitives.Interval(value, enums.Tags.LEASE_TIME)
elif name is enums.AttributeType.USAGE_LIMITS:
raise NotImplementedError()
elif name is enums.AttributeType.STATE:
return attributes.State(value)
elif name is enums.AttributeType.INITIAL_DATE:
return primitives.DateTime(value, enums.Tags.INITIAL_DATE)
elif name is enums.AttributeType.ACTIVATION_DATE:
return primitives.DateTime(value, enums.Tags.ACTIVATION_DATE)
elif name is enums.AttributeType.PROCESS_START_DATE:
return primitives.DateTime(value, enums.Tags.PROCESS_START_DATE)
elif name is enums.AttributeType.PROTECT_STOP_DATE:
return primitives.DateTime(value, enums.Tags.PROTECT_STOP_DATE)
elif name is enums.AttributeType.DEACTIVATION_DATE:
return primitives.DateTime(value, enums.Tags.DEACTIVATION_DATE)
elif name is enums.AttributeType.DESTROY_DATE:
return primitives.DateTime(value, enums.Tags.DESTROY_DATE)
elif name is enums.AttributeType.COMPROMISE_OCCURRENCE_DATE:
return primitives.DateTime(value,
enums.Tags.COMPROMISE_OCCURRENCE_DATE)
elif name is enums.AttributeType.COMPROMISE_DATE:
return primitives.DateTime(value, enums.Tags.COMPROMISE_DATE)
elif name is enums.AttributeType.REVOCATION_REASON:
raise NotImplementedError()
elif name is enums.AttributeType.ARCHIVE_DATE:
return primitives.DateTime(value, enums.Tags.ARCHIVE_DATE)
elif name is enums.AttributeType.OBJECT_GROUP:
return self._create_object_group(value)
elif name is enums.AttributeType.FRESH:
return primitives.Boolean(value, enums.Tags.FRESH)
elif name is enums.AttributeType.LINK:
raise NotImplementedError()
elif name is enums.AttributeType.APPLICATION_SPECIFIC_INFORMATION:
return self._create_application_specific_information(value)
elif name is enums.AttributeType.CONTACT_INFORMATION:
return self._create_contact_information(value)
elif name is enums.AttributeType.LAST_CHANGE_DATE:
return primitives.DateTime(value, enums.Tags.LAST_CHANGE_DATE)
elif name is enums.AttributeType.CUSTOM_ATTRIBUTE:
return attributes.CustomAttribute(value)
else:
if not isinstance(name, str):
raise ValueError('Unrecognized attribute type: '
'{0}'.format(name))
elif name.startswith('x-'):
# Custom attribute indicated
return attributes.CustomAttribute(value)
def test_init(self):
"""
Test that an Interval can be instantiated.
"""
interval = primitives.Interval(1)
self.assertEqual(1, interval.value)
