def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0): """ Read the data encoding the SignatureVerify 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. Raises: ValueError: Raised if the data attribute is missing from the encoded payload. """ super(SignatureVerifyRequestPayload, 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.CRYPTOGRAPHIC_PARAMETERS, local_stream): self._cryptographic_parameters = \ attributes.CryptographicParameters() self._cryptographic_parameters.read(local_stream, kmip_version=kmip_version) if self.is_tag_next(enums.Tags.DATA, local_stream): self._data = primitives.ByteString(tag=enums.Tags.DATA) self._data.read(local_stream, kmip_version=kmip_version) if self.is_tag_next(enums.Tags.DIGESTED_DATA, local_stream): self._digested_data = primitives.ByteString( tag=enums.Tags.DIGESTED_DATA) self._digested_data.read(local_stream, kmip_version=kmip_version) if self.is_tag_next(enums.Tags.SIGNATURE_DATA, local_stream): self._signature_data = primitives.ByteString( tag=enums.Tags.SIGNATURE_DATA) self._signature_data.read(local_stream, kmip_version=kmip_version) if self.is_tag_next(enums.Tags.CORRELATION_VALUE, local_stream): self._correlation_value = primitives.ByteString( tag=enums.Tags.CORRELATION_VALUE) self._correlation_value.read(local_stream, kmip_version=kmip_version) if self.is_tag_next(enums.Tags.INIT_INDICATOR, local_stream): self._init_indicator = primitives.Boolean( tag=enums.Tags.INIT_INDICATOR) self._init_indicator.read(local_stream, kmip_version=kmip_version) if self.is_tag_next(enums.Tags.FINAL_INDICATOR, local_stream): self._final_indicator = primitives.Boolean( tag=enums.Tags.FINAL_INDICATOR) self._final_indicator.read(local_stream, kmip_version=kmip_version) self.is_oversized(local_stream)
def test_equal_on_equal_and_empty(self): """ Test that the equality operator returns True when comparing two Boolean objects. """ a = primitives.Boolean() b = primitives.Boolean() 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 Boolean objects with the same values. """ a = primitives.Boolean(False) b = primitives.Boolean(False) 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 Boolean objects with different values. """ a = primitives.Boolean(True) b = primitives.Boolean(False) 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 Boolean objects. """ a = primitives.Boolean() b = primitives.Boolean() self.assertFalse(a != b) self.assertFalse(b != a)
def test_repr_false(self): """ Test that the representation of a Boolean object representing the value False is formatted properly. """ boolean = primitives.Boolean(False) self.assertEqual("Boolean(value=False)", repr(boolean))
def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0): super(RequestBatchItem, self).read( istream, kmip_version=kmip_version ) tstream = BytearrayStream(istream.read(self.length)) # Read the batch item operation self.operation = contents.Operation() self.operation.read(tstream, kmip_version=kmip_version) if kmip_version >= enums.KMIPVersion.KMIP_2_0: if self.is_tag_next(enums.Tags.EPHEMERAL, tstream): ephemeral = primitives.Boolean(tag=enums.Tags.EPHEMERAL) ephemeral.read(tstream, kmip_version=kmip_version) self._ephemeral = ephemeral # Read the unique batch item ID if it is present if self.is_tag_next(Tags.UNIQUE_BATCH_ITEM_ID, tstream): self.unique_batch_item_id = contents.UniqueBatchItemID() self.unique_batch_item_id.read(tstream, kmip_version=kmip_version) # Dynamically create the response payload class that belongs to the # operation self.request_payload = self.payload_factory.create( self.operation.value) self.request_payload.read(tstream, kmip_version=kmip_version) # Read the message extension if it is present if self.is_tag_next(Tags.MESSAGE_EXTENSION, tstream): self.message_extension = contents.MessageExtension() self.message_extension.read(tstream, kmip_version=kmip_version) self.is_oversized(tstream)
def final_indicator(self, value): if value is None: self._final_indicator = None elif isinstance(value, bool): self._final_indicator = primitives.Boolean( value=value, tag=enums.Tags.FINAL_INDICATOR) else: raise TypeError("Final indicator must be a boolean.")
def test_read_bad_encoding(self): """ Test that an Exception is raised when the Boolean read operation fails on a bad encoding. """ encoding = (b'\x42\x00\x00\x06\x00\x00\x00\x08') stream = utils.BytearrayStream(encoding) boolean = primitives.Boolean() self.assertRaises(Exception, boolean.read, stream)
def test_write_bad_value(self): """ Test that an Exception is raised when the Boolean write operation fails on a bad Boolean value. """ stream = utils.BytearrayStream() boolean = primitives.Boolean() boolean.value = 'invalid' self.assertRaises(Exception, boolean.write, stream)
def test_not_equal_on_type_mismatch(self): """ Test that the inequality operator returns True when comparing a Boolean object to a non-Boolean object. """ a = primitives.Boolean() 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 Boolean object to a non-Boolean object. """ a = primitives.Boolean() b = 'invalid' self.assertFalse(a == b) self.assertFalse(b == a)
def test_read_bad_value(self): """ Test that a ValueError is raised when the Boolean read operations reads a valid integer but invalid Boolean. """ encoding = ( b'\x42\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00' b'\x02') stream = utils.BytearrayStream(encoding) boolean = primitives.Boolean() self.assertRaises(ValueError, boolean.read, stream)
def ephemeral(self, value): if value is None: self._ephemeral = None elif isinstance(value, bool): ephemeral = primitives.Boolean( value=value, tag=enums.Tags.EPHEMERAL ) self._ephemeral = ephemeral else: raise TypeError("The ephemeral value must be a boolean.")
def test_read_false(self): """ Test that a Boolean object representing the value False can be read from a byte stream. """ encoding = ( b'\x42\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00' b'\x00') stream = utils.BytearrayStream(encoding) boolean = primitives.Boolean() boolean.read(stream) self.assertFalse(boolean.value)
def test_write_false(self): """ Test that a Boolean object representing the value False can be written to a byte stream. """ encoding = ( b'\x42\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00' b'\x00') stream = utils.BytearrayStream() boolean = primitives.Boolean(False) boolean.write(stream) self.assertEqual(encoding, stream.read())
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_validate_on_valid_unset(self): """ Test that a Boolean object with no preset value can be validated. """ boolean = primitives.Boolean() boolean.validate()
def test_validate_on_valid(self): """ Test that a Boolean object can be validated on good input. """ boolean = primitives.Boolean(True) boolean.validate()
def test_init_unset(self): """ Test that a Boolean object can be instantiated with no input. """ boolean = primitives.Boolean() self.assertEqual(True, boolean.value)
def test_str_false(self): """ Test that the string representation of a Boolean object representing the value False is formatted properly. """ self.assertEqual("False", str(primitives.Boolean(False)))
def test_repr_default(self): """ Test that the representation of a Boolean object is formatted properly """ boolean = primitives.Boolean() self.assertEqual("Boolean(value=True)", repr(boolean))
def test_init(self): """ Test that a Boolean object can be instantiated. """ boolean = primitives.Boolean(False) self.assertEqual(False, boolean.value)
def test_str_default(self): """ Test that the string representation of a Boolean object is formatted properly. """ self.assertEqual("True", str(primitives.Boolean()))