Exemplo n.º 1
0
    def __init__(self,
                 operation=None,
                 unique_batch_item_id=None,
                 result_status=None,
                 result_reason=None,
                 result_message=None,
                 async_correlation_value=None,
                 response_payload=None,
                 message_extension=None):
        super(ResponseBatchItem, self).__init__(tag=Tags.RESPONSE_BATCH_ITEM)

        self.payload_factory = ResponsePayloadFactory()

        self.operation = operation
        self.unique_batch_item_id = unique_batch_item_id
        self.result_status = result_status
        self.result_reason = result_reason
        self.result_message = result_message
        self.async_correlation_value = async_correlation_value
        self.response_payload = response_payload
        self.message_extension = message_extension
        self.validate()
Exemplo n.º 2
0
    def __init__(self,
                 operation=None,
                 unique_batch_item_id=None,
                 result_status=None,
                 result_reason=None,
                 result_message=None,
                 async_correlation_value=None,
                 response_payload=None,
                 message_extension=None):
        super(self.__class__, self).__init__(tag=Tags.RESPONSE_BATCH_ITEM)

        self.payload_factory = ResponsePayloadFactory()

        self.operation = operation
        self.unique_batch_item_id = unique_batch_item_id
        self.result_status = result_status
        self.result_reason = result_reason
        self.result_message = result_message
        self.async_correlation_value = async_correlation_value
        self.response_payload = response_payload
        self.message_extension = message_extension
        self.validate()
Exemplo n.º 3
0
 def setUp(self):
     super(TestResponsePayloadFactory, self).setUp()
     self.factory = ResponsePayloadFactory()
Exemplo n.º 4
0
class TestResponsePayloadFactory(testtools.TestCase):

    def setUp(self):
        super(TestResponsePayloadFactory, self).setUp()
        self.factory = ResponsePayloadFactory()

    def tearDown(self):
        super(TestResponsePayloadFactory, self).tearDown()

    def _test_not_implemented(self, func, args):
        self.assertRaises(NotImplementedError, func, args)

    def _test_payload_type(self, payload, payload_type):
        msg = "expected {0}, received {1}".format(payload_type, payload)
        self.assertIsInstance(payload, payload_type, msg)

    def test_create_create_payload(self):
        payload = self.factory.create(Operation.CREATE)
        self._test_payload_type(payload, create.CreateResponsePayload)

    def test_create_create_key_pair_payload(self):
        payload = self.factory.create(Operation.CREATE_KEY_PAIR)
        self._test_payload_type(
            payload, create_key_pair.CreateKeyPairResponsePayload)

    def test_create_register_payload(self):
        payload = self.factory.create(Operation.REGISTER)
        self._test_payload_type(payload, register.RegisterResponsePayload)

    def test_create_rekey_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.REKEY)

    def test_create_derive_key_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.DERIVE_KEY)

    def test_create_certify_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.CERTIFY)

    def test_create_recertify_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.RECERTIFY)

    def test_create_locate_payload(self):
        payload = self.factory.create(Operation.LOCATE)
        self._test_payload_type(payload, locate.LocateResponsePayload)

    def test_create_check_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.CHECK)

    def test_create_get_payload(self):
        payload = self.factory.create(Operation.GET)
        self._test_payload_type(payload, get.GetResponsePayload)

    def test_create_get_attributes_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.GET_ATTRIBUTES)

    def test_create_get_attributes_list_payload(self):
        payload = self.factory.create(Operation.GET_ATTRIBUTE_LIST)
        self._test_payload_type(
            payload, get_attribute_list.GetAttributeListResponsePayload)

    def test_create_add_attribute_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.ADD_ATTRIBUTE)

    def test_create_modify_attribute_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.MODIFY_ATTRIBUTE)

    def test_create_delete_attribute_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.DELETE_ATTRIBUTE)

    def test_create_obtain_lease_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.OBTAIN_LEASE)

    def test_create_get_usage_allocation_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.GET_USAGE_ALLOCATION)

    def test_create_activate_payload(self):
        payload = self.factory.create(Operation.ACTIVATE)
        self._test_payload_type(payload, activate.ActivateResponsePayload)

    def test_create_revoke_payload(self):
        payload = self.factory.create(Operation.REVOKE)
        self._test_payload_type(payload, revoke.RevokeResponsePayload)

    def test_create_destroy_payload(self):
        payload = self.factory.create(Operation.DESTROY)
        self._test_payload_type(payload, destroy.DestroyResponsePayload)

    def test_create_archive_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.ARCHIVE)

    def test_create_recover_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.RECOVER)

    def test_create_validate_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.VALIDATE)

    def test_create_query_payload(self):
        payload = self.factory.create(Operation.QUERY)
        self._test_payload_type(payload, query.QueryResponsePayload)

    def test_create_cancel_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.CANCEL)

    def test_create_poll_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.POLL)

    def test_create_notify_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.NOTIFY)

    def test_create_put_payload(self):
        self._test_not_implemented(
            self.factory.create, Operation.PUT)

    def test_create_rekey_key_pair_payload(self):
        payload = self.factory.create(Operation.REKEY_KEY_PAIR)
        self._test_payload_type(
            payload, rekey_key_pair.RekeyKeyPairResponsePayload)

    def test_create_discover_versions_payload(self):
        payload = self.factory.create(Operation.DISCOVER_VERSIONS)
        self._test_payload_type(
            payload, discover_versions.DiscoverVersionsResponsePayload)
Exemplo n.º 5
0
class ResponseBatchItem(Struct):

    def __init__(self,
                 operation=None,
                 unique_batch_item_id=None,
                 result_status=None,
                 result_reason=None,
                 result_message=None,
                 async_correlation_value=None,
                 response_payload=None,
                 message_extension=None):
        super(ResponseBatchItem, self).__init__(tag=Tags.RESPONSE_BATCH_ITEM)

        self.payload_factory = ResponsePayloadFactory()

        self.operation = operation
        self.unique_batch_item_id = unique_batch_item_id
        self.result_status = result_status
        self.result_reason = result_reason
        self.result_message = result_message
        self.async_correlation_value = async_correlation_value
        self.response_payload = response_payload
        self.message_extension = message_extension
        self.validate()

    def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        super(ResponseBatchItem, self).read(
            istream,
            kmip_version=kmip_version
        )
        tstream = BytearrayStream(istream.read(self.length))

        # Read the batch item operation if it is present
        if self.is_tag_next(Tags.OPERATION, tstream):
            self.operation = contents.Operation()
            self.operation.read(tstream, kmip_version=kmip_version)

        # 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)

        # Read the batch item result status
        self.result_status = contents.ResultStatus()
        self.result_status.read(tstream, kmip_version=kmip_version)

        # Read the batch item result reason if it is present
        if self.is_tag_next(Tags.RESULT_REASON, tstream):
            self.result_reason = contents.ResultReason()
            self.result_reason.read(tstream, kmip_version=kmip_version)

        # Read the batch item result message if it is present
        if self.is_tag_next(Tags.RESULT_MESSAGE, tstream):
            self.result_message = contents.ResultMessage()
            self.result_message.read(tstream, kmip_version=kmip_version)

        # Read the batch item asynchronous correlation value if it is present
        if self.is_tag_next(Tags.ASYNCHRONOUS_CORRELATION_VALUE, tstream):
            self.async_correlation_value = AsynchronousCorrelationValue()
            self.async_correlation_value.read(
                tstream,
                kmip_version=kmip_version
            )

        if (self.operation is not None):
            # Dynamically create the response payload class that belongs to the
            # operation
            expected = self.payload_factory.create(self.operation.value)
            if self.is_tag_next(expected.tag, tstream):
                self.response_payload = expected
                self.response_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)
        self.validate()

    def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        tstream = BytearrayStream()

        # Write the contents of the batch item to the stream
        if self.operation is not None:
            self.operation.write(tstream, kmip_version=kmip_version)
        if self.unique_batch_item_id is not None:
            self.unique_batch_item_id.write(tstream, kmip_version=kmip_version)

        self.result_status.write(tstream, kmip_version=kmip_version)

        if self.result_reason is not None:
            self.result_reason.write(tstream, kmip_version=kmip_version)
        if self.result_message is not None:
            self.result_message.write(tstream, kmip_version=kmip_version)
        if self.async_correlation_value is not None:
            self.async_correlation_value.write(
                tstream,
                kmip_version=kmip_version
            )
        if self.response_payload is not None:
            self.response_payload.write(tstream, kmip_version=kmip_version)
        if self.message_extension is not None:
            self.message_extension.write(tstream, kmip_version=kmip_version)

        # Write the length and value of the batch item
        self.length = tstream.length()
        super(ResponseBatchItem, self).write(
            ostream,
            kmip_version=kmip_version
        )
        ostream.write(tstream.buffer)

    def validate(self):
        pass
Exemplo n.º 6
0
 def setUp(self):
     super(TestResponsePayloadFactory, self).setUp()
     self.factory = ResponsePayloadFactory()
Exemplo n.º 7
0
class TestResponsePayloadFactory(testtools.TestCase):
    def setUp(self):
        super(TestResponsePayloadFactory, self).setUp()
        self.factory = ResponsePayloadFactory()

    def tearDown(self):
        super(TestResponsePayloadFactory, self).tearDown()

    def _test_not_implemented(self, func, args):
        self.assertRaises(NotImplementedError, func, args)

    def _test_payload_type(self, payload, payload_type):
        msg = "expected {0}, received {1}".format(payload_type, payload)
        self.assertIsInstance(payload, payload_type, msg)

    def test_create_create_payload(self):
        payload = self.factory.create(enums.Operation.CREATE)
        self._test_payload_type(payload, payloads.CreateResponsePayload)

    def test_create_create_key_pair_payload(self):
        payload = self.factory.create(enums.Operation.CREATE_KEY_PAIR)
        self._test_payload_type(payload, payloads.CreateKeyPairResponsePayload)

    def test_create_register_payload(self):
        payload = self.factory.create(enums.Operation.REGISTER)
        self._test_payload_type(payload, payloads.RegisterResponsePayload)

    def test_create_rekey_payload(self):
        payload = self.factory.create(enums.Operation.REKEY)
        self._test_payload_type(payload, payloads.RekeyResponsePayload)

    def test_create_derive_key_payload(self):
        payload = self.factory.create(enums.Operation.DERIVE_KEY)
        self._test_payload_type(payload, payloads.DeriveKeyResponsePayload)

    def test_create_certify_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.CERTIFY)

    def test_create_recertify_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.RECERTIFY)

    def test_create_locate_payload(self):
        payload = self.factory.create(enums.Operation.LOCATE)
        self._test_payload_type(payload, payloads.LocateResponsePayload)

    def test_create_check_payload(self):
        payload = self.factory.create(enums.Operation.CHECK)
        self._test_payload_type(payload, payloads.CheckResponsePayload)

    def test_create_get_payload(self):
        payload = self.factory.create(enums.Operation.GET)
        self._test_payload_type(payload, payloads.GetResponsePayload)

    def test_create_get_attributes_payload(self):
        payload = self.factory.create(enums.Operation.GET_ATTRIBUTES)
        self._test_payload_type(payload, payloads.GetAttributesResponsePayload)

    def test_create_get_attributes_list_payload(self):
        payload = self.factory.create(enums.Operation.GET_ATTRIBUTE_LIST)
        self._test_payload_type(payload,
                                payloads.GetAttributeListResponsePayload)

    def test_create_add_attribute_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.ADD_ATTRIBUTE)

    def test_create_modify_attribute_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.MODIFY_ATTRIBUTE)

    def test_create_delete_attribute_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.DELETE_ATTRIBUTE)

    def test_create_obtain_lease_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.OBTAIN_LEASE)

    def test_create_get_usage_allocation_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.GET_USAGE_ALLOCATION)

    def test_create_activate_payload(self):
        payload = self.factory.create(enums.Operation.ACTIVATE)
        self._test_payload_type(payload, payloads.ActivateResponsePayload)

    def test_create_revoke_payload(self):
        payload = self.factory.create(enums.Operation.REVOKE)
        self._test_payload_type(payload, payloads.RevokeResponsePayload)

    def test_create_destroy_payload(self):
        payload = self.factory.create(enums.Operation.DESTROY)
        self._test_payload_type(payload, payloads.DestroyResponsePayload)

    def test_create_archive_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.ARCHIVE)

    def test_create_recover_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.RECOVER)

    def test_create_validate_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.VALIDATE)

    def test_create_query_payload(self):
        payload = self.factory.create(enums.Operation.QUERY)
        self._test_payload_type(payload, payloads.QueryResponsePayload)

    def test_create_cancel_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.CANCEL)

    def test_create_poll_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.POLL)

    def test_create_notify_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.NOTIFY)

    def test_create_put_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.PUT)

    def test_create_rekey_key_pair_payload(self):
        payload = self.factory.create(enums.Operation.REKEY_KEY_PAIR)
        self._test_payload_type(payload, payloads.RekeyKeyPairResponsePayload)

    def test_create_discover_versions_payload(self):
        payload = self.factory.create(enums.Operation.DISCOVER_VERSIONS)
        self._test_payload_type(payload,
                                payloads.DiscoverVersionsResponsePayload)

    def test_create_encrypt_payload(self):
        payload = self.factory.create(enums.Operation.ENCRYPT)
        self._test_payload_type(payload, payloads.EncryptResponsePayload)

    def test_create_decrypt_payload(self):
        payload = self.factory.create(enums.Operation.DECRYPT)
        self._test_payload_type(payload, payloads.DecryptResponsePayload)

    def test_create_sign_payload(self):
        payload = self.factory.create(enums.Operation.SIGN)
        self._test_payload_type(payload, payloads.SignResponsePayload)

    def test_create_signature_verify_payload(self):
        payload = self.factory.create(enums.Operation.SIGNATURE_VERIFY)
        self._test_payload_type(payload,
                                payloads.SignatureVerifyResponsePayload)

    def test_create_mac_payload(self):
        payload = self.factory.create(enums.Operation.MAC)
        self._test_payload_type(payload, payloads.MACResponsePayload)

    def test_create_mac_verify_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.MAC_VERIFY)

    def test_create_rng_retrieve_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.RNG_RETRIEVE)

    def test_create_rng_seed_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.RNG_SEED)

    def test_create_hash_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.HASH)

    def test_create_create_split_key_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.CREATE_SPLIT_KEY)

    def test_create_join_split_key_payload(self):
        self._test_not_implemented(self.factory.create,
                                   enums.Operation.JOIN_SPLIT_KEY)
Exemplo n.º 8
0
class TestResponsePayloadFactory(testtools.TestCase):

    def setUp(self):
        super(TestResponsePayloadFactory, self).setUp()
        self.factory = ResponsePayloadFactory()

    def tearDown(self):
        super(TestResponsePayloadFactory, self).tearDown()

    def _test_not_implemented(self, func, args):
        self.assertRaises(NotImplementedError, func, args)

    def _test_payload_type(self, payload, payload_type):
        msg = "expected {0}, received {1}".format(payload_type, payload)
        self.assertIsInstance(payload, payload_type, msg)

    def test_create_create_payload(self):
        payload = self.factory.create(enums.Operation.CREATE)
        self._test_payload_type(payload, payloads.CreateResponsePayload)

    def test_create_create_key_pair_payload(self):
        payload = self.factory.create(enums.Operation.CREATE_KEY_PAIR)
        self._test_payload_type(
            payload,
            payloads.CreateKeyPairResponsePayload
        )

    def test_create_register_payload(self):
        payload = self.factory.create(enums.Operation.REGISTER)
        self._test_payload_type(payload, payloads.RegisterResponsePayload)

    def test_create_rekey_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.REKEY)

    def test_create_derive_key_payload(self):
        payload = self.factory.create(enums.Operation.DERIVE_KEY)
        self._test_payload_type(payload, payloads.DeriveKeyResponsePayload)

    def test_create_certify_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.CERTIFY
        )

    def test_create_recertify_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.RECERTIFY
        )

    def test_create_locate_payload(self):
        payload = self.factory.create(enums.Operation.LOCATE)
        self._test_payload_type(payload, payloads.LocateResponsePayload)

    def test_create_check_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.CHECK)

    def test_create_get_payload(self):
        payload = self.factory.create(enums.Operation.GET)
        self._test_payload_type(payload, payloads.GetResponsePayload)

    def test_create_get_attributes_payload(self):
        payload = self.factory.create(enums.Operation.GET_ATTRIBUTES)
        self._test_payload_type(
            payload,
            payloads.GetAttributesResponsePayload
        )

    def test_create_get_attributes_list_payload(self):
        payload = self.factory.create(enums.Operation.GET_ATTRIBUTE_LIST)
        self._test_payload_type(
            payload,
            payloads.GetAttributeListResponsePayload
        )

    def test_create_add_attribute_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.ADD_ATTRIBUTE
        )

    def test_create_modify_attribute_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.MODIFY_ATTRIBUTE
        )

    def test_create_delete_attribute_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.DELETE_ATTRIBUTE
        )

    def test_create_obtain_lease_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.OBTAIN_LEASE
        )

    def test_create_get_usage_allocation_payload(self):
        self._test_not_implemented(
            self.factory.create, enums.Operation.GET_USAGE_ALLOCATION)

    def test_create_activate_payload(self):
        payload = self.factory.create(enums.Operation.ACTIVATE)
        self._test_payload_type(payload, payloads.ActivateResponsePayload)

    def test_create_revoke_payload(self):
        payload = self.factory.create(enums.Operation.REVOKE)
        self._test_payload_type(payload, payloads.RevokeResponsePayload)

    def test_create_destroy_payload(self):
        payload = self.factory.create(enums.Operation.DESTROY)
        self._test_payload_type(payload, payloads.DestroyResponsePayload)

    def test_create_archive_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.ARCHIVE
        )

    def test_create_recover_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.RECOVER
        )

    def test_create_validate_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.VALIDATE
        )

    def test_create_query_payload(self):
        payload = self.factory.create(enums.Operation.QUERY)
        self._test_payload_type(payload, payloads.QueryResponsePayload)

    def test_create_cancel_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.CANCEL
        )

    def test_create_poll_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.POLL)

    def test_create_notify_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.NOTIFY
        )

    def test_create_put_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.PUT)

    def test_create_rekey_key_pair_payload(self):
        payload = self.factory.create(enums.Operation.REKEY_KEY_PAIR)
        self._test_payload_type(
            payload,
            payloads.RekeyKeyPairResponsePayload
        )

    def test_create_discover_versions_payload(self):
        payload = self.factory.create(enums.Operation.DISCOVER_VERSIONS)
        self._test_payload_type(
            payload,
            payloads.DiscoverVersionsResponsePayload
        )

    def test_create_encrypt_payload(self):
        payload = self.factory.create(enums.Operation.ENCRYPT)
        self._test_payload_type(payload, payloads.EncryptResponsePayload)

    def test_create_decrypt_payload(self):
        payload = self.factory.create(enums.Operation.DECRYPT)
        self._test_payload_type(payload, payloads.DecryptResponsePayload)

    def test_create_sign_payload(self):
        payload = self.factory.create(enums.Operation.SIGN)
        self._test_payload_type(payload, payloads.SignResponsePayload)

    def test_create_signature_verify_payload(self):
        payload = self.factory.create(enums.Operation.SIGNATURE_VERIFY)
        self._test_payload_type(
            payload,
            payloads.SignatureVerifyResponsePayload
        )

    def test_create_mac_payload(self):
        payload = self.factory.create(enums.Operation.MAC)
        self._test_payload_type(
            payload,
            payloads.MACResponsePayload
        )

    def test_create_mac_verify_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.MAC_VERIFY
        )

    def test_create_rng_retrieve_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.RNG_RETRIEVE
        )

    def test_create_rng_seed_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.RNG_SEED
        )

    def test_create_hash_payload(self):
        self._test_not_implemented(self.factory.create, enums.Operation.HASH)

    def test_create_create_split_key_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.CREATE_SPLIT_KEY
        )

    def test_create_join_split_key_payload(self):
        self._test_not_implemented(
            self.factory.create,
            enums.Operation.JOIN_SPLIT_KEY
        )
Exemplo n.º 9
0
class TestResponsePayloadFactory(testtools.TestCase):
    def setUp(self):
        super(TestResponsePayloadFactory, self).setUp()
        self.factory = ResponsePayloadFactory()

    def tearDown(self):
        super(TestResponsePayloadFactory, self).tearDown()

    def _test_not_implemented(self, func, args):
        self.assertRaises(NotImplementedError, func, args)

    def _test_payload_type(self, payload, payload_type):
        msg = "expected {0}, received {1}".format(payload_type, payload)
        self.assertIsInstance(payload, payload_type, msg)

    def test_create_create_payload(self):
        payload = self.factory.create(Operation.CREATE)
        self._test_payload_type(payload, create.CreateResponsePayload)

    def test_create_create_key_pair_payload(self):
        payload = self.factory.create(Operation.CREATE_KEY_PAIR)
        self._test_payload_type(payload,
                                create_key_pair.CreateKeyPairResponsePayload)

    def test_create_register_payload(self):
        payload = self.factory.create(Operation.REGISTER)
        self._test_payload_type(payload, register.RegisterResponsePayload)

    def test_create_rekey_payload(self):
        self._test_not_implemented(self.factory.create, Operation.REKEY)

    def test_create_derive_key_payload(self):
        self._test_not_implemented(self.factory.create, Operation.DERIVE_KEY)

    def test_create_certify_payload(self):
        self._test_not_implemented(self.factory.create, Operation.CERTIFY)

    def test_create_recertify_payload(self):
        self._test_not_implemented(self.factory.create, Operation.RECERTIFY)

    def test_create_locate_payload(self):
        payload = self.factory.create(Operation.LOCATE)
        self._test_payload_type(payload, locate.LocateResponsePayload)

    def test_create_check_payload(self):
        self._test_not_implemented(self.factory.create, Operation.CHECK)

    def test_create_get_payload(self):
        payload = self.factory.create(Operation.GET)
        self._test_payload_type(payload, get.GetResponsePayload)

    def test_create_get_attributes_payload(self):
        self._test_not_implemented(self.factory.create,
                                   Operation.GET_ATTRIBUTES)

    def test_create_get_attributes_list_payload(self):
        payload = self.factory.create(Operation.GET_ATTRIBUTE_LIST)
        self._test_payload_type(
            payload, get_attribute_list.GetAttributeListResponsePayload)

    def test_create_add_attribute_payload(self):
        self._test_not_implemented(self.factory.create,
                                   Operation.ADD_ATTRIBUTE)

    def test_create_modify_attribute_payload(self):
        self._test_not_implemented(self.factory.create,
                                   Operation.MODIFY_ATTRIBUTE)

    def test_create_delete_attribute_payload(self):
        self._test_not_implemented(self.factory.create,
                                   Operation.DELETE_ATTRIBUTE)

    def test_create_obtain_lease_payload(self):
        self._test_not_implemented(self.factory.create, Operation.OBTAIN_LEASE)

    def test_create_get_usage_allocation_payload(self):
        self._test_not_implemented(self.factory.create,
                                   Operation.GET_USAGE_ALLOCATION)

    def test_create_activate_payload(self):
        payload = self.factory.create(Operation.ACTIVATE)
        self._test_payload_type(payload, activate.ActivateResponsePayload)

    def test_create_revoke_payload(self):
        payload = self.factory.create(Operation.REVOKE)
        self._test_payload_type(payload, revoke.RevokeResponsePayload)

    def test_create_destroy_payload(self):
        payload = self.factory.create(Operation.DESTROY)
        self._test_payload_type(payload, destroy.DestroyResponsePayload)

    def test_create_archive_payload(self):
        self._test_not_implemented(self.factory.create, Operation.ARCHIVE)

    def test_create_recover_payload(self):
        self._test_not_implemented(self.factory.create, Operation.RECOVER)

    def test_create_validate_payload(self):
        self._test_not_implemented(self.factory.create, Operation.VALIDATE)

    def test_create_query_payload(self):
        payload = self.factory.create(Operation.QUERY)
        self._test_payload_type(payload, query.QueryResponsePayload)

    def test_create_cancel_payload(self):
        self._test_not_implemented(self.factory.create, Operation.CANCEL)

    def test_create_poll_payload(self):
        self._test_not_implemented(self.factory.create, Operation.POLL)

    def test_create_notify_payload(self):
        self._test_not_implemented(self.factory.create, Operation.NOTIFY)

    def test_create_put_payload(self):
        self._test_not_implemented(self.factory.create, Operation.PUT)

    def test_create_rekey_key_pair_payload(self):
        payload = self.factory.create(Operation.REKEY_KEY_PAIR)
        self._test_payload_type(payload,
                                rekey_key_pair.RekeyKeyPairResponsePayload)

    def test_create_discover_versions_payload(self):
        payload = self.factory.create(Operation.DISCOVER_VERSIONS)
        self._test_payload_type(
            payload, discover_versions.DiscoverVersionsResponsePayload)
Exemplo n.º 10
0
class ResponseBatchItem(Struct):

    def __init__(self,
                 operation=None,
                 unique_batch_item_id=None,
                 result_status=None,
                 result_reason=None,
                 result_message=None,
                 async_correlation_value=None,
                 response_payload=None,
                 message_extension=None):
        super(self.__class__, self).__init__(tag=Tags.RESPONSE_BATCH_ITEM)

        self.payload_factory = ResponsePayloadFactory()

        self.operation = operation
        self.unique_batch_item_id = unique_batch_item_id
        self.result_status = result_status
        self.result_reason = result_reason
        self.result_message = result_message
        self.async_correlation_value = async_correlation_value
        self.response_payload = response_payload
        self.message_extension = message_extension
        self.validate()

    def read(self, istream):
        super(self.__class__, self).read(istream)
        tstream = BytearrayStream(istream.read(self.length))

        # Read the batch item operation if it is present
        if self.is_tag_next(Tags.OPERATION, tstream):
            self.operation = contents.Operation()
            self.operation.read(tstream)

        # 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)

        # Read the batch item result status
        self.result_status = contents.ResultStatus()
        self.result_status.read(tstream)

        # Read the batch item result reason if it is present
        if self.is_tag_next(Tags.RESULT_REASON, tstream):
            self.result_reason = contents.ResultReason()
            self.result_reason.read(tstream)

        # Read the batch item result message if it is present
        if self.is_tag_next(Tags.RESULT_MESSAGE, tstream):
            self.result_message = contents.ResultMessage()
            self.result_message.read(tstream)

        # Read the batch item asynchronous correlation value if it is present
        if self.is_tag_next(Tags.ASYNCHRONOUS_CORRELATION_VALUE, tstream):
            self.async_correlation_value = AsynchronousCorrelationValue()
            self.async_correlation_value.read(tstream)

        # Dynamically create the response payload class that belongs to the
        # operation
        expected = self.payload_factory.create(self.operation.enum)
        if self.is_tag_next(expected.tag, tstream):
            self.response_payload = expected
            self.response_payload.read(tstream)

        # 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)

        self.is_oversized(tstream)
        self.validate()

    def write(self, ostream):
        tstream = BytearrayStream()

        # Write the contents of the batch item to the stream
        if self.operation is not None:
            self.operation.write(tstream)
        if self.unique_batch_item_id is not None:
            self.unique_batch_item_id.write(tstream)

        self.result_status.write(tstream)

        if self.result_reason is not None:
            self.result_reason.write(tstream)
        if self.result_message is not None:
            self.result_message.write(tstream)
        if self.async_correlation_value is not None:
            self.async_correlation_value.write(tstream)
        if self.response_payload is not None:
            self.response_payload.write(tstream)
        if self.message_extension is not None:
            self.message_extension.write(tstream)

        # Write the length and value of the batch item
        self.length = tstream.length()
        super(self.__class__, self).write(ostream)
        ostream.write(tstream.buffer)

    def validate(self):
        pass