From 20dbad505520d654cbc9a4e6c6919233ef1bfc15 Mon Sep 17 00:00:00 2001 From: Peter Hamilton Date: Tue, 29 Sep 2015 13:23:44 -0400 Subject: [PATCH] Updating support for the Enumeration primitive This change updates the Enumeration primitive, adding a fresh implementation and documentation. An updated unit test suite for the primitive is included. Numerous changes to Enumeration usage across the library are also included to comply with the updated implementation. --- kmip/core/attributes.py | 31 +- kmip/core/enums.py | 62 ++-- kmip/core/messages/contents.py | 57 ++-- kmip/core/messages/messages.py | 4 +- kmip/core/messages/payloads/get.py | 8 +- kmip/core/messages/payloads/locate.py | 6 +- kmip/core/messages/payloads/register.py | 2 +- kmip/core/misc.py | 8 +- kmip/core/objects.py | 23 +- kmip/core/primitives.py | 182 +++++++--- kmip/core/secrets.py | 9 +- kmip/core/server.py | 50 ++- kmip/demos/units/activate.py | 6 +- kmip/demos/units/create.py | 8 +- kmip/demos/units/create_key_pair.py | 6 +- kmip/demos/units/destroy.py | 6 +- kmip/demos/units/discover_versions.py | 6 +- kmip/demos/units/get.py | 10 +- kmip/demos/units/locate.py | 6 +- kmip/demos/units/query.py | 6 +- kmip/demos/units/register.py | 6 +- kmip/demos/units/revoke.py | 6 +- kmip/pie/client.py | 24 +- kmip/pie/factory.py | 10 +- kmip/services/kmip_client.py | 4 +- kmip/services/processor.py | 16 +- .../integration/services/test_integration.py | 51 +-- .../integration/services/test_kmip_client.py | 26 +- .../unit/core/attributes/test_attributes.py | 8 +- .../tests/unit/core/attributes/test_digest.py | 46 +-- .../tests/unit/core/messages/test_messages.py | 72 ++-- kmip/tests/unit/core/misc/test_misc.py | 8 +- .../unit/core/primitives/test_enumeration.py | 322 +++++++++++++----- kmip/tests/unit/core/test_server.py | 120 ++++--- kmip/tests/unit/pie/test_factory.py | 32 +- kmip/tests/unit/services/test_kmip_client.py | 14 +- 36 files changed, 732 insertions(+), 529 deletions(-) diff --git a/kmip/core/attributes.py b/kmip/core/attributes.py index bb48a6b..8722a58 100644 --- a/kmip/core/attributes.py +++ b/kmip/core/attributes.py @@ -65,10 +65,9 @@ class Name(Struct): class NameType(Enumeration): - ENUM_TYPE = enums.NameType - def __init__(self, value=None): - super(Name.NameType, self).__init__(value, Tags.NAME_TYPE) + super(Name.NameType, self).__init__( + enums.NameType, value, Tags.NAME_TYPE) def __init__(self, name_value=None, name_type=None): super(Name, self).__init__(tag=Tags.NAME) @@ -154,20 +153,17 @@ class Name(Struct): # 3.3 class ObjectType(Enumeration): - ENUM_TYPE = enums.ObjectType - def __init__(self, value=None): - super(ObjectType, self).__init__(value, Tags.OBJECT_TYPE) + super(ObjectType, self).__init__( + enums.ObjectType, value, Tags.OBJECT_TYPE) # 3.4 class CryptographicAlgorithm(Enumeration): - ENUM_TYPE = enums.CryptographicAlgorithm - def __init__(self, value=None): super(CryptographicAlgorithm, self).__init__( - value, Tags.CRYPTOGRAPHIC_ALGORITHM) + enums.CryptographicAlgorithm, value, Tags.CRYPTOGRAPHIC_ALGORITHM) # 3.5 @@ -187,7 +183,6 @@ class HashingAlgorithm(Enumeration): Object. See Sections 3.17 and 9.1.3.2.16 of the KMIP v1.1 specification for more information. """ - ENUM_TYPE = enums.HashingAlgorithm def __init__(self, value=HashingAlgorithmEnum.SHA_256): """ @@ -198,31 +193,29 @@ class HashingAlgorithm(Enumeration): (e.g., HashingAlgorithm.MD5). Optional, defaults to HashingAlgorithm.SHA_256. """ - super(HashingAlgorithm, self).__init__(value, Tags.HASHING_ALGORITHM) + super(HashingAlgorithm, self).__init__( + enums.HashingAlgorithm, value, Tags.HASHING_ALGORITHM) class CryptographicParameters(Struct): class BlockCipherMode(Enumeration): - ENUM_TYPE = enums.BlockCipherMode def __init__(self, value=None): super(CryptographicParameters.BlockCipherMode, self).__init__( - value, Tags.BLOCK_CIPHER_MODE) + enums.BlockCipherMode, value, Tags.BLOCK_CIPHER_MODE) class PaddingMethod(Enumeration): - ENUM_TYPE = enums.PaddingMethod def __init__(self, value=None): super(CryptographicParameters.PaddingMethod, self).__init__( - value, Tags.PADDING_METHOD) + enums.PaddingMethod, value, Tags.PADDING_METHOD) class KeyRoleType(Enumeration): - ENUM_TYPE = enums.KeyRoleType def __init__(self, value=None): super(CryptographicParameters.KeyRoleType, self).__init__( - value, Tags.KEY_ROLE_TYPE) + enums.KeyRoleType, value, Tags.KEY_ROLE_TYPE) def __init__(self, block_cipher_mode=None, @@ -293,7 +286,6 @@ class CertificateType(Enumeration): Object. See Sections 2.2.1 and 3.8 of the KMIP v1.1 specification for more information. """ - ENUM_TYPE = enums.CertificateTypeEnum def __init__(self, value=CertificateTypeEnum.X_509): """ @@ -304,7 +296,8 @@ class CertificateType(Enumeration): value, (e.g., CertificateTypeEnum.PGP). Optional, defaults to CertificateTypeEnum.X_509. """ - super(CertificateType, self).__init__(value, Tags.CERTIFICATE_TYPE) + super(CertificateType, self).__init__( + enums.CertificateTypeEnum, value, Tags.CERTIFICATE_TYPE) class DigestValue(ByteString): diff --git a/kmip/core/enums.py b/kmip/core/enums.py index daaea74..c64b12f 100644 --- a/kmip/core/enums.py +++ b/kmip/core/enums.py @@ -16,10 +16,10 @@ # In case of new content, remove the following line to enable flake8 tests # flake8: noqa -from enum import Enum +import enum -class AttributeType(Enum): +class AttributeType(enum.Enum): UNIQUE_IDENTIFIER = 'Unique Identifier' NAME = 'Name' OBJECT_TYPE = 'Object Type' @@ -61,7 +61,7 @@ class AttributeType(Enum): CUSTOM_ATTRIBUTE = 'Custom Attribute' -class ConformanceClause(Enum): +class ConformanceClause(enum.Enum): """ The specification of KMIP features supported by KMIP clients and servers. @@ -83,7 +83,7 @@ class ConformanceClause(Enum): STORAGE = 11 -class AuthenticationSuite(Enum): +class AuthenticationSuite(enum.Enum): """ The type of authentication suite used by KMIP clients and servers. @@ -98,7 +98,7 @@ class AuthenticationSuite(Enum): # 9.1.1.2 -class Types(Enum): +class Types(enum.Enum): DEFAULT = 0x00 STRUCTURE = 0x01 INTEGER = 0x02 @@ -113,7 +113,7 @@ class Types(Enum): # 9.1.3.1 -class Tags(Enum): +class Tags(enum.Enum): DEFAULT = 0x420000 ACTIVATION_DATE = 0x420001 APPLICATION_DATA = 0x420002 @@ -303,13 +303,13 @@ class Tags(Enum): # 9.1.3.2.1 -class CredentialType(Enum): +class CredentialType(enum.Enum): USERNAME_AND_PASSWORD = 0x00000001 DEVICE = 0x00000002 # 9.1.3.2.2 -class KeyCompressionType(Enum): +class KeyCompressionType(enum.Enum): EC_PUBLIC_KEY_TYPE_UNCOMPRESSED = 0x00000001 EC_PUBLIC_KEY_TYPE_X9_62_COMPRESSED_PRIME = 0x00000002 EC_PUBLIC_KEY_TYPE_X9_62_COMPRESSED_CHAR2 = 0x00000003 @@ -317,7 +317,7 @@ class KeyCompressionType(Enum): # 9.1.3.2.3 -class KeyFormatType(Enum): +class KeyFormatType(enum.Enum): RAW = 0x00000001 OPAQUE = 0x00000002 PKCS_1 = 0x00000003 @@ -340,7 +340,7 @@ class KeyFormatType(Enum): # 9.1.3.2.4 -class WrappingMethod(Enum): +class WrappingMethod(enum.Enum): ENCRYPT = 0x00000001 MAC_SIGN = 0x00000002 ENCRYPT_THEN_MAC_SIGN = 0x00000003 @@ -349,7 +349,7 @@ class WrappingMethod(Enum): # 9.1.3.2.6 -class CertificateTypeEnum(Enum): +class CertificateTypeEnum(enum.Enum): """ The type of a Certificate Managed Object. @@ -360,32 +360,32 @@ class CertificateTypeEnum(Enum): # 9.1.3.2.8 -class SplitKeyMethod(Enum): +class SplitKeyMethod(enum.Enum): XOR = 0x00000001 POLYNOMIAL_SHARING_GF = 0x00000002 POLYNOMIAL_SHARING_PRIME_FIELD = 0x00000003 # 9.1.3.2.9 -class SecretDataType(Enum): +class SecretDataType(enum.Enum): PASSWORD = 0x00000001 SEED = 0x00000002 # 9.1.3.2.10 -class OpaqueDataType(Enum): +class OpaqueDataType(enum.Enum): NONE = 0x80000000 # Not defined by the standard, but we need something. # The standard does say that values starting 0x8xxxxxx # are considered extensions # 9.1.3.2.11 -class NameType(Enum): +class NameType(enum.Enum): UNINTERPRETED_TEXT_STRING = 0x00000001 URI = 0x00000002 # 9.1.3.2.12 -class ObjectType(Enum): +class ObjectType(enum.Enum): CERTIFICATE = 0x00000001 SYMMETRIC_KEY = 0x00000002 PUBLIC_KEY = 0x00000003 @@ -397,7 +397,7 @@ class ObjectType(Enum): # 9.1.3.2.13 -class CryptographicAlgorithm(Enum): +class CryptographicAlgorithm(enum.Enum): DES = 0x00000001 TRIPLE_DES = 0x00000002 # '3DES' is invalid syntax AES = 0x00000003 @@ -426,7 +426,7 @@ class CryptographicAlgorithm(Enum): # 9.1.3.2.14 -class BlockCipherMode(Enum): +class BlockCipherMode(enum.Enum): CBC = 0x00000001 ECB = 0x00000002 PCBC = 0x00000003 @@ -447,7 +447,7 @@ class BlockCipherMode(Enum): # 9.1.3.2.15 -class PaddingMethod(Enum): +class PaddingMethod(enum.Enum): NONE = 0x00000001 OAEP = 0x00000002 PKCS5 = 0x00000003 @@ -461,7 +461,7 @@ class PaddingMethod(Enum): # 9.1.3.2.16 -class HashingAlgorithm(Enum): +class HashingAlgorithm(enum.Enum): MD2 = 0x00000001 MD4 = 0x00000002 MD5 = 0x00000003 @@ -476,7 +476,7 @@ class HashingAlgorithm(Enum): # 9.1.3.2.17 -class KeyRoleType(Enum): +class KeyRoleType(enum.Enum): BDK = 0x00000001 CVK = 0x00000002 DEK = 0x00000003 @@ -501,7 +501,7 @@ class KeyRoleType(Enum): # 9.1.3.2.24 -class QueryFunction(Enum): +class QueryFunction(enum.Enum): QUERY_OPERATIONS = 0x00000001 QUERY_OBJECTS = 0x00000002 QUERY_SERVER_INFORMATION = 0x00000003 @@ -510,7 +510,7 @@ class QueryFunction(Enum): QUERY_EXTENSION_MAP = 0x00000006 # 9.1.3.2.27 -class Operation(Enum): +class Operation(enum.Enum): CREATE = 0x00000001 CREATE_KEY_PAIR = 0x00000002 REGISTER = 0x00000003 @@ -544,7 +544,7 @@ class Operation(Enum): # 9.1.3.2.28 -class ResultStatus(Enum): +class ResultStatus(enum.Enum): SUCCESS = 0x00000000 OPERATION_FAILED = 0x00000001 OPERATION_PENDING = 0x00000002 @@ -552,7 +552,7 @@ class ResultStatus(Enum): # 9.1.3.2.29 -class ResultReason(Enum): +class ResultReason(enum.Enum): ITEM_NOT_FOUND = 0x00000001 RESPONSE_TOO_LARGE = 0x00000002 AUTHENTICATION_NOT_SUCCESSFUL = 0x00000003 @@ -575,21 +575,21 @@ class ResultReason(Enum): # 9.1.3.2.30 -class BatchErrorContinuationOption(Enum): +class BatchErrorContinuationOption(enum.Enum): CONTINUE = 0x00000001 STOP = 0x00000002 UNDO = 0x00000003 # 9.1.3.2.32 -class EncodingOption(Enum): +class EncodingOption(enum.Enum): NO_ENCODING = 0x00000001 TTLV_ENCODING = 0x00000002 # 9.1.3.3 # 9.1.3.3.1 -class CryptographicUsageMask(Enum): +class CryptographicUsageMask(enum.Enum): SIGN = 0x00000001 VERIFY = 0x00000002 ENCRYPT = 0x00000004 @@ -612,16 +612,16 @@ class CryptographicUsageMask(Enum): TRANSLATE_UNWRAP = 0x00080000 # 9.1.3.2.33 -class ObjectGroupMember(Enum): +class ObjectGroupMember(enum.Enum): GROUP_MEMBER_FRESH = 0x00000001 GROUP_MEMBER_DEFAULT = 0x00000002 # 9.1.3.3.2 -class StorageStatusMask(Enum): +class StorageStatusMask(enum.Enum): ONLINE_STORAGE = 0x00000001 ARCHIVAL_STORAGE = 0x00000002 -class RevocationReasonCode(Enum): +class RevocationReasonCode(enum.Enum): UNSPECIFIED = 0x00000001 KEY_COMPROMISE = 0x00000002 CA_COMPROMISE = 0x00000003 diff --git a/kmip/core/messages/contents.py b/kmip/core/messages/contents.py index 3b2d982..dbe64da 100644 --- a/kmip/core/messages/contents.py +++ b/kmip/core/messages/contents.py @@ -13,13 +13,7 @@ # License for the specific language governing permissions and limitations # under the License. -from kmip.core.enums import BatchErrorContinuationOption -from kmip.core.enums import KeyCompressionType -from kmip.core.enums import Operation -from kmip.core.enums import ResultStatus -from kmip.core.enums import ResultReason -from kmip.core.enums import Tags - +from kmip.core import enums from kmip.core import objects from kmip.core import utils @@ -38,17 +32,17 @@ class ProtocolVersion(Struct): class ProtocolVersionMajor(Integer): def __init__(self, value=None): super(ProtocolVersion.ProtocolVersionMajor, self).\ - __init__(value, Tags.PROTOCOL_VERSION_MAJOR) + __init__(value, enums.Tags.PROTOCOL_VERSION_MAJOR) class ProtocolVersionMinor(Integer): def __init__(self, value=None): super(ProtocolVersion.ProtocolVersionMinor, self).\ - __init__(value, Tags.PROTOCOL_VERSION_MINOR) + __init__(value, enums.Tags.PROTOCOL_VERSION_MINOR) def __init__(self, protocol_version_major=None, protocol_version_minor=None): - super(ProtocolVersion, self).__init__(Tags.PROTOCOL_VERSION) + super(ProtocolVersion, self).__init__(enums.Tags.PROTOCOL_VERSION) if protocol_version_major is None: self.protocol_version_major = \ @@ -139,37 +133,37 @@ class ProtocolVersion(Struct): # 6.2 class Operation(Enumeration): - ENUM_TYPE = Operation def __init__(self, value=None): - super(Operation, self).__init__(value, Tags.OPERATION) + super(Operation, self).__init__( + enums.Operation, value, enums.Tags.OPERATION) # 6.3 class MaximumResponseSize(Integer): def __init__(self, value=None): super(MaximumResponseSize, self).\ - __init__(value, Tags.MAXIMUM_RESPONSE_SIZE) + __init__(value, enums.Tags.MAXIMUM_RESPONSE_SIZE) # 6.4 class UniqueBatchItemID(ByteString): def __init__(self, value=None): super(UniqueBatchItemID, self)\ - .__init__(value, Tags.UNIQUE_BATCH_ITEM_ID) + .__init__(value, enums.Tags.UNIQUE_BATCH_ITEM_ID) # 6.5 class TimeStamp(DateTime): def __init__(self, value=None): - super(TimeStamp, self).__init__(value, Tags.TIME_STAMP) + super(TimeStamp, self).__init__(value, enums.Tags.TIME_STAMP) # 6.6 class Authentication(Struct): def __init__(self, credential=None): - super(Authentication, self).__init__(Tags.AUTHENTICATION) + super(Authentication, self).__init__(enums.Tags.AUTHENTICATION) self.credential = credential def read(self, istream): @@ -202,70 +196,69 @@ class Authentication(Struct): class AsynchronousIndicator(Boolean): def __init__(self, value=None): super(AsynchronousIndicator, self).\ - __init__(value, Tags.ASYNCHRONOUS_INDICATOR) + __init__(value, enums.Tags.ASYNCHRONOUS_INDICATOR) # 6.8 class AsynchronousCorrelationValue(ByteString): def __init__(self, value=None): super(AsynchronousCorrelationValue, self).\ - __init__(value, Tags.ASYNCHRONOUS_CORRELATION_VALUE) + __init__(value, enums.Tags.ASYNCHRONOUS_CORRELATION_VALUE) # 6.9 class ResultStatus(Enumeration): - ENUM_TYPE = ResultStatus def __init__(self, value=None): - super(ResultStatus, self).__init__(value, Tags.RESULT_STATUS) + super(ResultStatus, self).__init__( + enums.ResultStatus, value, enums.Tags.RESULT_STATUS) # 6.10 class ResultReason(Enumeration): - ENUM_TYPE = ResultReason def __init__(self, value=None): - super(ResultReason, self).__init__(value, Tags.RESULT_REASON) + super(ResultReason, self).__init__( + enums.ResultReason, value, enums.Tags.RESULT_REASON) # 6.11 class ResultMessage(TextString): def __init__(self, value=None): - super(ResultMessage, self).__init__(value, Tags.RESULT_MESSAGE) + super(ResultMessage, self).__init__(value, enums.Tags.RESULT_MESSAGE) # 6.12 class BatchOrderOption(Boolean): def __init__(self, value=None): super(BatchOrderOption, self).\ - __init__(value, Tags.BATCH_ORDER_OPTION) + __init__(value, enums.Tags.BATCH_ORDER_OPTION) # 6.13 class BatchErrorContinuationOption(Enumeration): - ENUM_TYPE = BatchErrorContinuationOption def __init__(self, value=None): - super(BatchErrorContinuationOption, self).\ - __init__(value, Tags.BATCH_ERROR_CONTINUATION_OPTION) + super(BatchErrorContinuationOption, self).__init__( + BatchErrorContinuationOption, value, + enums.Tags.BATCH_ERROR_CONTINUATION_OPTION) # 6.14 class BatchCount(Integer): def __init__(self, value=None): - super(BatchCount, self).__init__(value, Tags.BATCH_COUNT) + super(BatchCount, self).__init__(value, enums.Tags.BATCH_COUNT) # 6.16 class MessageExtension(Struct): def __init__(self): - super(MessageExtension, self).__init__(Tags.MESSAGE_EXTENSION) + super(MessageExtension, self).__init__(enums.Tags.MESSAGE_EXTENSION) # 9.1.3.2.2 class KeyCompressionType(Enumeration): - ENUM_TYPE = KeyCompressionType def __init__(self, value=None): - super(KeyCompressionType, self).\ - __init__(value, Tags.KEY_COMPRESSION_TYPE) + super(KeyCompressionType, self).__init__( + enums.KeyCompressionType, value, enums.Tags.KEY_COMPRESSION_TYPE) diff --git a/kmip/core/messages/messages.py b/kmip/core/messages/messages.py index b4690ac..843df76 100644 --- a/kmip/core/messages/messages.py +++ b/kmip/core/messages/messages.py @@ -200,7 +200,7 @@ class RequestBatchItem(Struct): # Dynamically create the response payload class that belongs to the # operation self.request_payload = self.payload_factory.create( - self.operation.enum) + self.operation.value) self.request_payload.read(tstream) # Read the message extension if it is present @@ -290,7 +290,7 @@ class ResponseBatchItem(Struct): # Dynamically create the response payload class that belongs to the # operation - expected = self.payload_factory.create(self.operation.enum) + 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) diff --git a/kmip/core/messages/payloads/get.py b/kmip/core/messages/payloads/get.py index 462688c..9a50256 100644 --- a/kmip/core/messages/payloads/get.py +++ b/kmip/core/messages/payloads/get.py @@ -32,19 +32,17 @@ class GetRequestPayload(Struct): # 9.1.3.2.2 class KeyCompressionType(Enumeration): - ENUM_TYPE = enums.KeyCompressionType def __init__(self, value=None): super(GetRequestPayload.KeyCompressionType, self).__init__( - value, Tags.KEY_COMPRESSION_TYPE) + enums.KeyCompressionType, value, Tags.KEY_COMPRESSION_TYPE) # 9.1.3.2.3 class KeyFormatType(Enumeration): - ENUM_TYPE = enums.KeyFormatType def __init__(self, value=None): super(GetRequestPayload.KeyFormatType, self).__init__( - value, Tags.KEY_FORMAT_TYPE) + enums.KeyFormatType, value, Tags.KEY_FORMAT_TYPE) def __init__(self, unique_identifier=None, @@ -130,7 +128,7 @@ class GetResponsePayload(Struct): self.object_type.read(tstream) self.unique_identifier.read(tstream) - secret_type = self.object_type.enum + secret_type = self.object_type.value self.secret = self.secret_factory.create(secret_type) self.secret.read(tstream) diff --git a/kmip/core/messages/payloads/locate.py b/kmip/core/messages/payloads/locate.py index bece4ae..b05ee81 100644 --- a/kmip/core/messages/payloads/locate.py +++ b/kmip/core/messages/payloads/locate.py @@ -30,11 +30,10 @@ class LocateRequestPayload(Struct): # 9.1.3.2.33 class ObjectGroupMember(Enumeration): - ENUM_TYPE = enums.ObjectGroupMember def __init__(self, value=None): super(LocateRequestPayload.ObjectGroupMember, self).__init__( - value, Tags.OBJECT_GROUP_MEMBER) + enums.ObjectGroupMember, value, Tags.OBJECT_GROUP_MEMBER) class MaximumItems(Integer): def __init__(self, value=None): @@ -43,11 +42,10 @@ class LocateRequestPayload(Struct): # 9.1.3.3.2 class StorageStatusMask(Enumeration): - ENUM_TYPE = enums.StorageStatusMask def __init__(self, value=None): super(LocateRequestPayload.StorageStatusMask, self).__init__( - value, Tags.STORAGE_STATUS_MASK) + enums.StorageStatusMask, value, Tags.STORAGE_STATUS_MASK) def __init__(self, maximum_items=None, storage_status_mask=None, object_group_member=None, attributes=None): diff --git a/kmip/core/messages/payloads/register.py b/kmip/core/messages/payloads/register.py index 2682dba..113a294 100644 --- a/kmip/core/messages/payloads/register.py +++ b/kmip/core/messages/payloads/register.py @@ -51,7 +51,7 @@ class RegisterRequestPayload(Struct): self.object_type.read(tstream) self.template_attribute.read(tstream) - secret_type = self.object_type.enum + secret_type = self.object_type.value secret = self.secret_factory.create(secret_type) if self.is_tag_next(secret.tag, tstream): diff --git a/kmip/core/misc.py b/kmip/core/misc.py index 05b4355..4bcdd60 100644 --- a/kmip/core/misc.py +++ b/kmip/core/misc.py @@ -76,7 +76,6 @@ class QueryFunction(Enumeration): KMIP server. See Sections 4.25 and 9.1.3.2.24 of the KMIP 1.1 specification for more information. """ - ENUM_TYPE = QueryFunctionEnum def __init__(self, value=None): """ @@ -87,7 +86,8 @@ class QueryFunction(Enumeration): (e.g., QueryFunction.QUERY_OPERATIONS). Optional, default to None. """ - super(QueryFunction, self).__init__(value, Tags.QUERY_FUNCTION) + super(QueryFunction, self).__init__( + QueryFunctionEnum, value, Tags.QUERY_FUNCTION) class VendorIdentification(TextString): @@ -216,7 +216,6 @@ class KeyFormatType(Enumeration): is returned when using the Get operation. See Sections 2.1.3, 2.1.7, 3.17, 4.11, and 9.1.3.2.3 of the KMIP 1.1 specification for more information. """ - ENUM_TYPE = KeyFormatTypeEnum def __init__(self, value=KeyFormatTypeEnum.RAW): """ @@ -227,4 +226,5 @@ class KeyFormatType(Enumeration): (e.g., KeyFormatType.PKCS_1). Optional, default to KeyFormatType.RAW. """ - super(KeyFormatType, self).__init__(value, Tags.KEY_FORMAT_TYPE) + super(KeyFormatType, self).__init__( + KeyFormatTypeEnum, value, Tags.KEY_FORMAT_TYPE) diff --git a/kmip/core/objects.py b/kmip/core/objects.py index 0f80b51..159f360 100644 --- a/kmip/core/objects.py +++ b/kmip/core/objects.py @@ -136,11 +136,9 @@ class Credential(Struct): class CredentialType(Enumeration): - ENUM_TYPE = CredentialType - def __init__(self, value=None): super(Credential.CredentialType, self).__init__( - value, Tags.CREDENTIAL_TYPE) + CredentialType, value, Tags.CREDENTIAL_TYPE) class UsernamePasswordCredential(Struct): @@ -323,9 +321,9 @@ class Credential(Struct): self.credential_type.read(tstream) # Use the type to determine what credential value to read - if self.credential_type.enum is CredentialType.USERNAME_AND_PASSWORD: + if self.credential_type.value is CredentialType.USERNAME_AND_PASSWORD: self.credential_value = self.UsernamePasswordCredential() - elif self.credential_type.enum is CredentialType.DEVICE: + elif self.credential_type.value is CredentialType.DEVICE: self.credential_value = self.DeviceCredential() else: # TODO (peter-hamilton) Use more descriptive error here @@ -354,11 +352,10 @@ class Credential(Struct): class KeyBlock(Struct): class KeyCompressionType(Enumeration): - ENUM_TYPE = enums.KeyCompressionType def __init__(self, value=None): super(KeyBlock.KeyCompressionType, self).__init__( - value, Tags.KEY_COMPRESSION_TYPE) + enums.KeyCompressionType, value, Tags.KEY_COMPRESSION_TYPE) def __init__(self, key_format_type=None, @@ -562,17 +559,17 @@ class KeyValue(Struct): # 2.1.5 class WrappingMethod(Enumeration): - ENUM_TYPE = enums.WrappingMethod def __init__(self, value=None): - super(WrappingMethod, self).__init__(value, Tags.WRAPPING_METHOD) + super(WrappingMethod, self).__init__( + enums.WrappingMethod, value, Tags.WRAPPING_METHOD) class EncodingOption(Enumeration): - ENUM_TYPE = enums.EncodingOption def __init__(self, value=None): - super(EncodingOption, self).__init__(value, Tags.ENCODING_OPTION) + super(EncodingOption, self).__init__( + enums.EncodingOption, value, Tags.ENCODING_OPTION) class KeyInformation(Struct): @@ -1182,11 +1179,11 @@ class ExtensionInformation(Struct): # 3.31, 9.1.3.2.19 class RevocationReasonCode(Enumeration): - ENUM_TYPE = RevocationReasonCodeEnum def __init__(self, value=RevocationReasonCodeEnum.UNSPECIFIED): super(RevocationReasonCode, self).__init__( - value=value, tag=Tags.REVOCATION_REASON_CODE) + RevocationReasonCodeEnum, value=value, + tag=Tags.REVOCATION_REASON_CODE) # 3.31 diff --git a/kmip/core/primitives.py b/kmip/core/primitives.py index a615427..59ff91e 100644 --- a/kmip/core/primitives.py +++ b/kmip/core/primitives.py @@ -13,6 +13,7 @@ # License for the specific language governing permissions and limitations # under the License. +import enum as enumeration import logging import six import struct @@ -20,13 +21,10 @@ import sys import time from struct import pack, unpack -from enum import Enum - -from kmip.core.enums import Types -from kmip.core.enums import Tags from kmip.core.errors import ErrorStrings +from kmip.core import enums from kmip.core import errors from kmip.core import exceptions from kmip.core import utils @@ -37,7 +35,7 @@ class Base(object): TYPE_SIZE = 1 LENGTH_SIZE = 4 - def __init__(self, tag=Tags.DEFAULT, type=Types.DEFAULT): + def __init__(self, tag=enums.Tags.DEFAULT, type=enums.Types.DEFAULT): self.tag = tag self.type = type self.length = None @@ -54,7 +52,7 @@ class Base(object): tts = istream.read(self.TAG_SIZE) tag = unpack('!I', b'\x00' + tts[0:self.TAG_SIZE])[0] - enum_tag = Tags(tag) + enum_tag = enums.Tags(tag) # Verify that the tag matches for the current object if enum_tag is not self.tag: @@ -71,7 +69,7 @@ class Base(object): '{0} bytes'.format(num_bytes)) typ = unpack('!B', tts)[0] - enum_typ = Types(typ) + enum_typ = enums.Types(typ) if enum_typ is not self.type: raise errors.ReadValueError(Base.__name__, 'type', @@ -100,10 +98,10 @@ class Base(object): ostream.write(pack('!I', self.tag.value)[1:]) def write_type(self, ostream): - if type(self.type) is not Types: + if type(self.type) is not enums.Types: msg = ErrorStrings.BAD_EXP_RECV raise TypeError(msg.format(Base.__name__, 'type', - Types, type(self.type))) + enums.Types, type(self.type))) ostream.write(pack('!B', self.type.value)) def write_length(self, ostream): @@ -157,8 +155,8 @@ class Base(object): class Struct(Base): - def __init__(self, tag=Tags.DEFAULT): - super(Struct, self).__init__(tag, type=Types.STRUCTURE) + def __init__(self, tag=enums.Tags.DEFAULT): + super(Struct, self).__init__(tag, type=enums.Types.STRUCTURE) # NOTE (peter-hamilton) If seen, should indicate repr needs to be defined def __repr__(self): @@ -172,8 +170,8 @@ class Integer(Base): MIN = -2147483648 MAX = 2147483647 - def __init__(self, value=None, tag=Tags.DEFAULT, signed=True): - super(Integer, self).__init__(tag, type=Types.INTEGER) + def __init__(self, value=None, tag=enums.Tags.DEFAULT, signed=True): + super(Integer, self).__init__(tag, type=enums.Types.INTEGER) self.value = value if self.value is None: @@ -266,7 +264,7 @@ class LongInteger(Base): MIN = -9223372036854775808 MAX = 9223372036854775807 - def __init__(self, value=0, tag=Tags.DEFAULT): + def __init__(self, value=0, tag=enums.Tags.DEFAULT): """ Create a LongInteger. @@ -275,7 +273,7 @@ class LongInteger(Base): tag (Tags): An enumeration defining the tag of the LongInteger. Optional, defaults to Tags.DEFAULT. """ - super(LongInteger, self).__init__(tag, type=Types.LONG_INTEGER) + super(LongInteger, self).__init__(tag, type=enums.Types.LONG_INTEGER) self.value = value self.length = LongInteger.LENGTH @@ -367,9 +365,10 @@ class BigInteger(Base): Section 9.1 of the KMIP 1.1 specification. """ - def __init__(self, value=0, tag=Tags.DEFAULT): - super(BigInteger, self).__init__(tag, type=Types.BIG_INTEGER) + def __init__(self, value=0, tag=enums.Tags.DEFAULT): + super(BigInteger, self).__init__(tag, type=enums.Types.BIG_INTEGER) self.value = value + self.validate() def read(self, istream): @@ -486,41 +485,132 @@ class BigInteger(Base): return NotImplemented -class Enumeration(Integer): - ENUM_TYPE = None +class Enumeration(Base): + """ + An encodeable object representing an enumeration. + + An Enumeration is one of the KMIP primitive object types. It is encoded as + an unsigned, big-endian, 32-bit integer. For more information, see Section + 9.1 of the KMIP 1.1 specification. + """ + LENGTH = 4 + + # Bounds for unsigned 32-bit integers + MIN = 0 + MAX = 4294967296 + + def __init__(self, enum, value=None, tag=enums.Tags.DEFAULT): + """ + Create an Enumeration. + + Args: + enum (class): The enumeration class of which value is a member + (e.g., Tags). Required. + value (int): The value of the Enumeration, must be an integer + (e.g., Tags.DEFAULT). Optional, defaults to None. + tag (Tags): An enumeration defining the tag of the Enumeration. + Optional, defaults to Tags.DEFAULT. + """ + super(Enumeration, self).__init__(tag, enums.Types.ENUMERATION) + + self.value = value + self.enum = enum + self.length = Enumeration.LENGTH - def __init__(self, value=None, tag=Tags.DEFAULT): - self.enum = value self.validate() - if self.enum is None: - super(Enumeration, self).__init__(None, tag, False) - else: - super(Enumeration, self).__init__(self.enum.value, tag, False) - self.type = Types.ENUMERATION - def read(self, istream): + """ + Read the encoding of the Enumeration from the input stream. + + Args: + istream (stream): A buffer containing the encoded bytes of an + Enumeration. Usually a BytearrayStream object. Required. + + Raises: + InvalidPrimitiveLength: if the Enumeration encoding read in has an + invalid encoded length. + InvalidPaddingBytes: if the Enumeration encoding read in does not + use zeroes for its padding bytes. + """ super(Enumeration, self).read(istream) - self.enum = self.ENUM_TYPE(self.value) + + # Check for a valid length before even trying to parse the value. + if self.length != Enumeration.LENGTH: + raise exceptions.InvalidPrimitiveLength( + "enumeration length must be {0}".format(Enumeration.LENGTH)) + + # Decode the Enumeration value and the padding bytes. + value = unpack('!I', istream.read(Enumeration.LENGTH))[0] + self.value = self.enum(value) + pad = unpack('!I', istream.read(Enumeration.LENGTH))[0] + + # Verify that the padding bytes are zero bytes. + if pad is not 0: + raise exceptions.InvalidPaddingBytes("padding bytes must be zero") + self.validate() def write(self, ostream): + """ + Write the encoding of the Enumeration to the output stream. + + Args: + ostream (stream): A buffer to contain the encoded bytes of an + Enumeration. Usually a BytearrayStream object. Required. + """ super(Enumeration, self).write(ostream) + ostream.write(pack('!I', self.value.value)) + ostream.write(pack('!I', 0)) def validate(self): - self.__validate() + """ + Verify that the value of the Enumeration is valid. - def __validate(self): - if self.enum is not None: - if not isinstance(self.enum, Enum): - raise TypeError("expected {0}, observed {1}".format( - type(self.enum), Enum)) + Raises: + TypeError: if the enum is not of type Enum + ValueError: if the value is not of the expected Enum subtype or if + the value cannot be represented by an unsigned 32-bit integer + """ + if not isinstance(self.enum, enumeration.EnumMeta): + raise TypeError( + 'enumeration type {0} must be of type EnumMeta'.format( + self.enum)) + if self.value is not None: + if not isinstance(self.value, self.enum): + raise TypeError( + 'enumeration {0} must be of type {1}'.format( + self.value, self.enum)) + if type(self.value.value) not in six.integer_types: + raise TypeError('enumeration value must be an int') + else: + if self.value.value > Enumeration.MAX: + raise ValueError( + 'enumeration value greater than accepted max') + elif self.value.value < Enumeration.MIN: + raise ValueError( + 'enumeration value less than accepted min') def __repr__(self): - return "{0}(value={1})".format(type(self).__name__, self.enum) + enum = "enum={0}".format(self.enum.__name__) + value = "value={0}".format(self.value) + tag = "tag={0}".format(self.tag) + return "Enumeration({0}, {1}, {2})".format(enum, value, tag) def __str__(self): - return "{0}.{1}".format(type(self.enum).__name__, self.enum.name) + return str(self.value) + + def __eq__(self, other): + if isinstance(other, Enumeration): + return ((self.enum == other.enum) and (self.value == other.value)) + else: + return NotImplemented + + def __ne__(self, other): + if isinstance(other, Enumeration): + return not self.__eq__(other) + else: + return NotImplemented class Boolean(Base): @@ -534,7 +624,7 @@ class Boolean(Base): """ LENGTH = 8 - def __init__(self, value=True, tag=Tags.DEFAULT): + def __init__(self, value=True, tag=enums.Tags.DEFAULT): """ Create a Boolean object. @@ -543,7 +633,7 @@ class Boolean(Base): tag (Tags): An enumeration defining the tag of the Boolean object. Optional, defaults to Tags.DEFAULT. """ - super(Boolean, self).__init__(tag, type=Types.BOOLEAN) + super(Boolean, self).__init__(tag, type=enums.Types.BOOLEAN) self.logger = logging.getLogger(__name__) self.value = value self.length = self.LENGTH @@ -649,8 +739,8 @@ class TextString(Base): PADDING_SIZE = 8 BYTE_FORMAT = '!c' - def __init__(self, value=None, tag=Tags.DEFAULT): - super(TextString, self).__init__(tag, type=Types.TEXT_STRING) + def __init__(self, value=None, tag=enums.Tags.DEFAULT): + super(TextString, self).__init__(tag, type=enums.Types.TEXT_STRING) if value is None: self.value = '' @@ -744,8 +834,8 @@ class ByteString(Base): PADDING_SIZE = 8 BYTE_FORMAT = '!B' - def __init__(self, value=None, tag=Tags.DEFAULT): - super(ByteString, self).__init__(tag, type=Types.BYTE_STRING) + def __init__(self, value=None, tag=enums.Tags.DEFAULT): + super(ByteString, self).__init__(tag, type=enums.Types.BYTE_STRING) if value is None: self.value = bytes() @@ -843,7 +933,7 @@ class DateTime(LongInteger): more information, see Section 9.1 of the KMIP 1.1 specification. """ - def __init__(self, value=None, tag=Tags.DEFAULT): + def __init__(self, value=None, tag=enums.Tags.DEFAULT): """ Create a DateTime. @@ -857,7 +947,7 @@ class DateTime(LongInteger): if value is None: value = int(time.time()) super(DateTime, self).__init__(value, tag) - self.type = Types.DATE_TIME + self.type = enums.Types.DATE_TIME def __repr__(self): return "DateTime(value={0}, tag={1})".format(self.value, self.tag) @@ -881,8 +971,8 @@ class Interval(Base): MIN = 0 MAX = 4294967296 - def __init__(self, value=0, tag=Tags.DEFAULT): - super(Interval, self).__init__(tag, type=Types.INTERVAL) + def __init__(self, value=0, tag=enums.Tags.DEFAULT): + super(Interval, self).__init__(tag, type=enums.Types.INTERVAL) self.value = value self.length = Interval.LENGTH diff --git a/kmip/core/secrets.py b/kmip/core/secrets.py index b7439fc..167f510 100644 --- a/kmip/core/secrets.py +++ b/kmip/core/secrets.py @@ -235,11 +235,10 @@ class SplitKey(Struct): value, Tags.SPLIT_KEY_THRESHOLD) class SplitKeyMethod(Enumeration): - ENUM_TYPE = enums.SplitKeyMethod def __init__(self, value=None): super(SplitKey.SplitKeyMethod, self).__init__( - value, Tags.SPLIT_KEY_METHOD) + enums.SplitKeyMethod, value, Tags.SPLIT_KEY_METHOD) class PrimeFieldSize(BigInteger): @@ -361,11 +360,10 @@ class Template(Struct): class SecretData(Struct): class SecretDataType(Enumeration): - ENUM_TYPE = enums.SecretDataType def __init__(self, value=None): super(SecretData.SecretDataType, self).__init__( - value, Tags.SECRET_DATA_TYPE) + enums.SecretDataType, value, Tags.SECRET_DATA_TYPE) def __init__(self, secret_data_type=None, @@ -411,11 +409,10 @@ class SecretData(Struct): class OpaqueObject(Struct): class OpaqueDataType(Enumeration): - ENUM_TYPE = enums.OpaqueDataType def __init__(self, value=None): super(OpaqueObject.OpaqueDataType, self).__init__( - value, Tags.OPAQUE_DATA_TYPE) + enums.OpaqueDataType, value, Tags.OPAQUE_DATA_TYPE) class OpaqueDataValue(ByteString): diff --git a/kmip/core/server.py b/kmip/core/server.py index 1065eb8..4751291 100644 --- a/kmip/core/server.py +++ b/kmip/core/server.py @@ -102,24 +102,18 @@ class KMIPImpl(KMIP): bit_length = 256 attributes = template_attribute.attributes ret_attributes = [] - if object_type.enum != OT.SYMMETRIC_KEY: + if object_type.value != OT.SYMMETRIC_KEY: self.logger.debug('invalid object type') return self._get_invalid_field_result('invalid object type') try: - alg_attr =\ - self._validate_req_field(attributes, - AT.CRYPTOGRAPHIC_ALGORITHM.value, - (CA.AES.value,), - 'unsupported algorithm') - len_attr = self._validate_req_field(attributes, - AT.CRYPTOGRAPHIC_LENGTH.value, - (128, 256, 512), - 'unsupported key length', - False) - self._validate_req_field(attributes, - AT.CRYPTOGRAPHIC_USAGE_MASK.value, - (), - '') + alg_attr = self._validate_req_field( + attributes, AT.CRYPTOGRAPHIC_ALGORITHM.value, + (CA.AES,), 'unsupported algorithm') + len_attr = self._validate_req_field( + attributes, AT.CRYPTOGRAPHIC_LENGTH.value, + (128, 256, 512), 'unsupported key length', False) + self._validate_req_field( + attributes, AT.CRYPTOGRAPHIC_USAGE_MASK.value, (), '') except InvalidFieldException as e: self.logger.debug('InvalidFieldException raised') return e.result @@ -158,7 +152,7 @@ class KMIPImpl(KMIP): if object_type is None: self.logger.debug('invalid object type') return self._get_missing_field_result('object type') - if object_type.enum != OT.SYMMETRIC_KEY: + if object_type.value != OT.SYMMETRIC_KEY: self.logger.debug('invalid object type') return self._get_invalid_field_result('invalid object type') if secret is None or not isinstance(secret, SymmetricKey): @@ -173,18 +167,14 @@ class KMIPImpl(KMIP): self.logger.debug('Verifying all attributes are valid and set') try: - self._validate_req_field(attributes, - AT.CRYPTOGRAPHIC_ALGORITHM.value, - (CA.AES.value,), - 'unsupported algorithm') - self._validate_req_field(attributes, - AT.CRYPTOGRAPHIC_LENGTH.value, - (128, 256, 512), - 'unsupported key length') - self._validate_req_field(attributes, - AT.CRYPTOGRAPHIC_USAGE_MASK.value, - (), - '') + self._validate_req_field( + attributes, AT.CRYPTOGRAPHIC_ALGORITHM.value, (CA.AES,), + 'unsupported algorithm') + self._validate_req_field( + attributes, AT.CRYPTOGRAPHIC_LENGTH.value, (128, 256, 512), + 'unsupported key length') + self._validate_req_field( + attributes, AT.CRYPTOGRAPHIC_USAGE_MASK.value, (), '') except InvalidFieldException as e: self.logger.debug('InvalidFieldException raised') return RegisterResult(e.result.result_status, @@ -220,7 +210,7 @@ class KMIPImpl(KMIP): if key_format_type is None: self.logger.debug('key format type is None, setting to raw') key_format_type = KeyFormatType(KeyFormatTypeEnum.RAW) - if key_format_type.enum != KeyFormatTypeEnum.RAW: + if key_format_type.value != KeyFormatTypeEnum.RAW: self.logger.debug('key format type is not raw') reason = ResultReason(ResultReasonEnum. KEY_FORMAT_TYPE_NOT_SUPPORTED) @@ -370,7 +360,7 @@ class KMIPImpl(KMIP): self.logger.debug('crypto_alg set on key block') self.logger.debug('adding crypto algorithm attribute') at = AT.CRYPTOGRAPHIC_ALGORITHM - alg = key_block.cryptographic_algorithm.enum + alg = key_block.cryptographic_algorithm.value attributes.append(self.attribute_factory.create_attribute(at, alg)) if key_block.cryptographic_length is not None: self.logger.debug('crypto_length set on key block') diff --git a/kmip/demos/units/activate.py b/kmip/demos/units/activate.py index a3865d8..72208eb 100644 --- a/kmip/demos/units/activate.py +++ b/kmip/demos/units/activate.py @@ -54,12 +54,12 @@ if __name__ == '__main__': # Display operation results logger.info('activate() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('activated UUID: {0}'.format(result.uuid.value)) else: logger.info('activate() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('activate() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/create.py b/kmip/demos/units/create.py index 8a08cc1..dc3a677 100644 --- a/kmip/demos/units/create.py +++ b/kmip/demos/units/create.py @@ -122,16 +122,16 @@ if __name__ == '__main__': # Display operation results logger.info('create() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('created object type: {0}'.format( - result.object_type.enum)) + result.object_type.value)) logger.info('created UUID: {0}'.format(result.uuid.value)) logger.info('created template attribute: {0}'. format(result.template_attribute)) else: logger.info('create() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('create() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/create_key_pair.py b/kmip/demos/units/create_key_pair.py index 681eb0d..3d16e26 100644 --- a/kmip/demos/units/create_key_pair.py +++ b/kmip/demos/units/create_key_pair.py @@ -125,9 +125,9 @@ if __name__ == '__main__': # Display operation results logger.info('create_key_pair() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('created private key UUID: {0}'.format( result.private_key_uuid)) logger.info('created public key UUID: {0}'.format( @@ -144,6 +144,6 @@ if __name__ == '__main__': logger, result.public_key_template_attribute) else: logger.info('create() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('create() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/destroy.py b/kmip/demos/units/destroy.py index 3429060..87e1bde 100644 --- a/kmip/demos/units/destroy.py +++ b/kmip/demos/units/destroy.py @@ -73,12 +73,12 @@ if __name__ == '__main__': # Display operation results logger.info('destroy() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('destroyed UUID: {0}'.format(result.uuid.value)) else: logger.info('destroy() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('destroy() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/discover_versions.py b/kmip/demos/units/discover_versions.py index ade4512..b651baf 100644 --- a/kmip/demos/units/discover_versions.py +++ b/kmip/demos/units/discover_versions.py @@ -49,9 +49,9 @@ if __name__ == '__main__': # Display operation results logger.info('discover_versions() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: protocol_versions = result.protocol_versions if isinstance(protocol_versions, list): logger.info('number of protocol versions returned: {0}'.format( @@ -63,6 +63,6 @@ if __name__ == '__main__': logger.info('number of protocol versions returned: 0') else: logger.info('discover_versions() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('discover_versions() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/get.py b/kmip/demos/units/get.py index 7fba7cb..6a95c9a 100644 --- a/kmip/demos/units/get.py +++ b/kmip/demos/units/get.py @@ -92,16 +92,16 @@ if __name__ == '__main__': # Display operation results logger.info('get() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('retrieved object type: {0}'.format( - result.object_type.enum)) + result.object_type.value)) logger.info('retrieved UUID: {0}'.format(result.uuid.value)) - utils.log_secret(logger, result.object_type.enum, result.secret) + utils.log_secret(logger, result.object_type.value, result.secret) else: logger.info('get() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('get() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/locate.py b/kmip/demos/units/locate.py index 858dbdb..7aa521c 100644 --- a/kmip/demos/units/locate.py +++ b/kmip/demos/units/locate.py @@ -88,14 +88,14 @@ if __name__ == '__main__': # Display operation results logger.info('locate() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('located UUIDs:') for uuid in result.uuids: logger.info('{0}'.format(uuid)) else: logger.info('get() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('get() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/query.py b/kmip/demos/units/query.py index 254241d..300e044 100644 --- a/kmip/demos/units/query.py +++ b/kmip/demos/units/query.py @@ -69,9 +69,9 @@ if __name__ == '__main__': # Display operation results logger.info('query() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: operations = result.operations object_types = result.object_types vendor_identification = result.vendor_identification @@ -106,6 +106,6 @@ if __name__ == '__main__': else: logger.info('query() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('query() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/register.py b/kmip/demos/units/register.py index 06fbf78..7a1717c 100644 --- a/kmip/demos/units/register.py +++ b/kmip/demos/units/register.py @@ -73,14 +73,14 @@ if __name__ == '__main__': # Display operation results logger.info('register() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('registered UUID: {0}'.format(result.uuid.value)) logger.info('registered template attribute: {0}'. format(result.template_attribute)) else: logger.info('register() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('register() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/demos/units/revoke.py b/kmip/demos/units/revoke.py index 3c4c317..ba4fb69 100644 --- a/kmip/demos/units/revoke.py +++ b/kmip/demos/units/revoke.py @@ -58,12 +58,12 @@ if __name__ == '__main__': # Display operation results logger.info('revoke() result status: {0}'.format( - result.result_status.enum)) + result.result_status.value)) - if result.result_status.enum == ResultStatus.SUCCESS: + if result.result_status.value == ResultStatus.SUCCESS: logger.info('revoked UUID: {0}'.format(result.unique_identifier.value)) else: logger.info('revoke() result reason: {0}'.format( - result.result_reason.enum)) + result.result_reason.value)) logger.info('revoke() result message: {0}'.format( result.result_message.value)) diff --git a/kmip/pie/client.py b/kmip/pie/client.py index 04c1586..9c4a144 100644 --- a/kmip/pie/client.py +++ b/kmip/pie/client.py @@ -170,12 +170,12 @@ class ProxyKmipClient(api.KmipClient): # Create the symmetric key and handle the results result = self.proxy.create(enums.ObjectType.SYMMETRIC_KEY, template) - status = result.result_status.enum + status = result.result_status.value if status == enums.ResultStatus.SUCCESS: uid = result.uuid.value return uid else: - reason = result.result_reason.enum + reason = result.result_reason.value message = result.result_message.value raise exceptions.KmipOperationFailure(status, reason, message) @@ -215,13 +215,13 @@ class ProxyKmipClient(api.KmipClient): # Create the asymmetric key pair and handle the results result = self.proxy.create_key_pair(common_template_attribute=template) - status = result.result_status.enum + status = result.result_status.value if status == enums.ResultStatus.SUCCESS: public_uid = result.public_key_uuid.value private_uid = result.private_key_uuid.value return public_uid, private_uid else: - reason = result.result_reason.enum + reason = result.result_reason.value message = result.result_message.value raise exceptions.KmipOperationFailure(status, reason, message) @@ -265,12 +265,12 @@ class ProxyKmipClient(api.KmipClient): secret = self.object_factory.convert(managed_object) result = self.proxy.register(object_type, template, secret) - status = result.result_status.enum + status = result.result_status.value if status == enums.ResultStatus.SUCCESS: uid = result.uuid.value return uid else: - reason = result.result_reason.enum + reason = result.result_reason.value message = result.result_message.value raise exceptions.KmipOperationFailure(status, reason, message) @@ -300,12 +300,12 @@ class ProxyKmipClient(api.KmipClient): # Get the managed object and handle the results result = self.proxy.get(uid) - status = result.result_status.enum + status = result.result_status.value if status == enums.ResultStatus.SUCCESS: managed_object = self.object_factory.convert(result.secret) return managed_object else: - reason = result.result_reason.enum + reason = result.result_reason.value message = result.result_message.value raise exceptions.KmipOperationFailure(status, reason, message) @@ -333,12 +333,12 @@ class ProxyKmipClient(api.KmipClient): # Get the list of attribute names for a managed object. result = self.proxy.get_attribute_list(uid) - status = result.result_status.enum + status = result.result_status.value if status == enums.ResultStatus.SUCCESS: attribute_names = sorted(result.names) return attribute_names else: - reason = result.result_reason.enum + reason = result.result_reason.value message = result.result_message.value raise exceptions.KmipOperationFailure(status, reason, message) @@ -368,11 +368,11 @@ class ProxyKmipClient(api.KmipClient): # Destroy the managed object and handle the results result = self.proxy.destroy(uid) - status = result.result_status.enum + status = result.result_status.value if status == enums.ResultStatus.SUCCESS: return else: - reason = result.result_reason.enum + reason = result.result_reason.value message = result.result_message.value raise exceptions.KmipOperationFailure(status, reason, message) diff --git a/kmip/pie/factory.py b/kmip/pie/factory.py index c1772ad..efb87fa 100644 --- a/kmip/pie/factory.py +++ b/kmip/pie/factory.py @@ -72,7 +72,7 @@ class ObjectFactory: raise TypeError("object type unsupported and cannot be converted") def _build_pie_certificate(self, cert): - certificate_type = cert.certificate_type.enum + certificate_type = cert.certificate_type.value value = cert.certificate_value.value if certificate_type == enums.CertificateTypeEnum.X_509: @@ -81,10 +81,10 @@ class ObjectFactory: raise TypeError("core certificate type not supported") def _build_pie_key(self, key, cls): - algorithm = key.key_block.cryptographic_algorithm.enum + algorithm = key.key_block.cryptographic_algorithm.value length = key.key_block.cryptographic_length.value value = key.key_block.key_value.key_material.value - format_type = key.key_block.key_format_type.enum + format_type = key.key_block.key_format_type.value if cls is pobjects.SymmetricKey: key = cls(algorithm, length, value) @@ -99,13 +99,13 @@ class ObjectFactory: return cls(algorithm, length, value, format_type) def _build_pie_secret_data(self, secret): - secret_data_type = secret.secret_data_type.enum + secret_data_type = secret.secret_data_type.value value = secret.key_block.key_value.key_material.value return pobjects.SecretData(value, secret_data_type) def _build_pie_opaque_object(self, obj): - opaque_type = obj.opaque_data_type.enum + opaque_type = obj.opaque_data_type.value value = obj.opaque_data_value.value return pobjects.OpaqueObject(value, opaque_type) diff --git a/kmip/services/kmip_client.py b/kmip/services/kmip_client.py index 73634ba..435b915 100644 --- a/kmip/services/kmip_client.py +++ b/kmip/services/kmip_client.py @@ -475,7 +475,7 @@ class KMIPProxy(KMIP): def _process_batch_items(self, response): results = [] for batch_item in response.batch_items: - operation = batch_item.operation.enum + operation = batch_item.operation.value processor = self._get_batch_item_processor(operation) result = processor(batch_item) results.append(result) @@ -597,7 +597,7 @@ class KMIPProxy(KMIP): if unique_identifier is not None: uuid = attr.UniqueIdentifier(unique_identifier) if key_format_type is not None: - kft = get.GetRequestPayload.KeyFormatType(key_format_type.enum) + kft = get.GetRequestPayload.KeyFormatType(key_format_type.value) if key_compression_type is not None: kct = key_compression_type kct = get.GetRequestPayload.KeyCompressionType(kct) diff --git a/kmip/services/processor.py b/kmip/services/processor.py index ead0770..3f5cb26 100644 --- a/kmip/services/processor.py +++ b/kmip/services/processor.py @@ -109,16 +109,16 @@ class Processor(object): response_payload = None message_extension = None - if result_status.enum is RS.SUCCESS: + if result_status.value is RS.SUCCESS: response_payload = result[3] - elif result_status.enum is RS.OPERATION_FAILED: + elif result_status.value is RS.OPERATION_FAILED: failure_occurred = True result_reason = result[1] - elif result_status.enum is RS.OPERATION_PENDING: + elif result_status.value is RS.OPERATION_PENDING: # TODO (peter-hamilton) Need to add a way to track async # TODO (peter-hamilton) operations. asyn_cv = b'\x00' - elif result_status.enum is RS.OPERATION_UNDONE: + elif result_status.value is RS.OPERATION_UNDONE: result_reason = result[1] else: msg = 'Unrecognized operation result status: {0}' @@ -135,13 +135,13 @@ class Processor(object): response_batch_items.append(resp_bi) if failure_occurred: - if batch_error_cont_option.enum is BECO.STOP: + if batch_error_cont_option.value is BECO.STOP: break - elif batch_error_cont_option.enum is BECO.UNDO: + elif batch_error_cont_option.value is BECO.UNDO: # TODO (peter-hamilton) Tell client to undo operations. # TODO (peter-hamilton) Unclear what response should be. break - elif batch_error_cont_option.enum is BECO.CONTINUE: + elif batch_error_cont_option.value is BECO.CONTINUE: continue else: msg = 'Unrecognized batch error continuation option: {0}' @@ -161,7 +161,7 @@ class Processor(object): raise NotImplementedError() def _process_operation(self, operation, payload): - op = operation.enum + op = operation.value if op is Operation.CREATE: return self._process_create_request(payload) diff --git a/kmip/tests/integration/services/test_integration.py b/kmip/tests/integration/services/test_integration.py index 9a15a3a..3231bf0 100644 --- a/kmip/tests/integration/services/test_integration.py +++ b/kmip/tests/integration/services/test_integration.py @@ -170,7 +170,7 @@ class TestIntegration(TestCase): :param result_status_value: value of the result status """ - result_status = result.result_status.enum + result_status = result.result_status.value # Error check the result status type and value expected = result_status_type @@ -303,7 +303,7 @@ class TestIntegration(TestCase): result = self.client.discover_versions() expected = ResultStatus.SUCCESS - observed = result.result_status.enum + observed = result.result_status.value self.assertEqual(expected, observed) @@ -326,7 +326,7 @@ class TestIntegration(TestCase): result = self.client.query(query_functions=query_functions) expected = ResultStatus.SUCCESS - observed = result.result_status.enum + observed = result.result_status.value self.assertEqual(expected, observed) @@ -338,14 +338,14 @@ class TestIntegration(TestCase): result = self._create_symmetric_key(key_name=key_name) self._check_result_status(result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(result.object_type.enum, ObjectType, + self._check_object_type(result.object_type.value, ObjectType, ObjectType.SYMMETRIC_KEY) self._check_uuid(result.uuid.value, str) result = self.client.get(uuid=result.uuid.value, credential=None) self._check_result_status(result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(result.object_type.enum, ObjectType, + self._check_object_type(result.object_type.value, ObjectType, ObjectType.SYMMETRIC_KEY) self._check_uuid(result.uuid.value, str) @@ -370,12 +370,12 @@ class TestIntegration(TestCase): ResultStatus.OPERATION_FAILED) expected = ResultReason - observed = type(result.result_reason.enum) + observed = type(result.result_reason.value) self.assertEqual(expected, observed) expected = ResultReason.ITEM_NOT_FOUND - observed = result.result_reason.enum + observed = result.result_reason.value self.assertEqual(expected, observed) @@ -434,7 +434,7 @@ class TestIntegration(TestCase): result = self.client.get(uuid=uuid, credential=None) self._check_result_status(result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(result.object_type.enum, ObjectType, + self._check_object_type(result.object_type.value, ObjectType, ObjectType.SYMMETRIC_KEY) self._check_uuid(result.uuid.value, str) @@ -469,12 +469,12 @@ class TestIntegration(TestCase): ResultStatus.OPERATION_FAILED) expected = ResultReason - observed = type(result.result_reason.enum) + observed = type(result.result_reason.value) self.assertEqual(expected, observed) expected = ResultReason.ITEM_NOT_FOUND - observed = result.result_reason.enum + observed = result.result_reason.value self.assertEqual(expected, observed) @@ -500,13 +500,13 @@ class TestIntegration(TestCase): self._check_result_status(priv_key_result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(priv_key_result.object_type.enum, ObjectType, + self._check_object_type(priv_key_result.object_type.value, ObjectType, ObjectType.PRIVATE_KEY) self._check_uuid(priv_key_result.uuid.value, str) self._check_result_status(pub_key_result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(pub_key_result.object_type.enum, ObjectType, + self._check_object_type(pub_key_result.object_type.value, ObjectType, ObjectType.PUBLIC_KEY) self._check_uuid(pub_key_result.uuid.value, str) @@ -552,8 +552,8 @@ class TestIntegration(TestCase): ResultStatus.OPERATION_FAILED) expected = ResultReason - observed_priv = type(priv_key_destroyed_result.result_reason.enum) - observed_pub = type(pub_key_destroyed_result.result_reason.enum) + observed_priv = type(priv_key_destroyed_result.result_reason.value) + observed_pub = type(pub_key_destroyed_result.result_reason.value) self.assertEqual(expected, observed_priv) self.assertEqual(expected, observed_pub) @@ -664,7 +664,7 @@ class TestIntegration(TestCase): self._check_result_status(priv_key_result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(priv_key_result.object_type.enum, ObjectType, + self._check_object_type(priv_key_result.object_type.value, ObjectType, ObjectType.PRIVATE_KEY) self._check_uuid(priv_key_result.uuid.value, str) @@ -704,7 +704,7 @@ class TestIntegration(TestCase): ResultStatus.OPERATION_FAILED) expected = ResultReason - priv_observed = type(priv_key_destroyed_result.result_reason.enum) + priv_observed = type(priv_key_destroyed_result.result_reason.value) self.assertEqual(expected, priv_observed) @@ -771,7 +771,7 @@ class TestIntegration(TestCase): self._check_result_status(pub_key_result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(pub_key_result.object_type.enum, ObjectType, + self._check_object_type(pub_key_result.object_type.value, ObjectType, ObjectType.PUBLIC_KEY) self._check_uuid(pub_key_result.uuid.value, str) @@ -801,7 +801,7 @@ class TestIntegration(TestCase): self._check_result_status(pub_key_destroyed_result, ResultStatus, ResultStatus.OPERATION_FAILED) expected = ResultReason - pub_observed = type(pub_key_destroyed_result.result_reason.enum) + pub_observed = type(pub_key_destroyed_result.result_reason.value) self.assertEqual(expected, pub_observed) @@ -911,7 +911,7 @@ class TestIntegration(TestCase): self._check_result_status(cert_result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(cert_result.object_type.enum, ObjectType, + self._check_object_type(cert_result.object_type.value, ObjectType, ObjectType.CERTIFICATE) self._check_uuid(cert_result.uuid.value, str) @@ -947,7 +947,7 @@ class TestIntegration(TestCase): ResultStatus.OPERATION_FAILED) expected = ResultReason - cert_observed = type(cert_result_destroyed_result.result_reason.enum) + cert_observed = type(cert_result_destroyed_result.result_reason.value) self.assertEqual(expected, cert_observed) @@ -1018,7 +1018,7 @@ class TestIntegration(TestCase): self._check_result_status(pass_result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(pass_result.object_type.enum, ObjectType, + self._check_object_type(pass_result.object_type.value, ObjectType, ObjectType.SECRET_DATA) self._check_uuid(pass_result.uuid.value, str) @@ -1055,7 +1055,7 @@ class TestIntegration(TestCase): ResultStatus.OPERATION_FAILED) expected = ResultReason - pass_observed = type(pass_result_destroyed_result.result_reason.enum) + pass_observed = type(pass_result_destroyed_result.result_reason.value) self.assertEqual(expected, pass_observed) @@ -1113,8 +1113,9 @@ class TestIntegration(TestCase): self._check_result_status(opaque_obj_result, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(opaque_obj_result.object_type.enum, ObjectType, - ObjectType.OPAQUE_DATA) + self._check_object_type( + opaque_obj_result.object_type.value, ObjectType, + ObjectType.OPAQUE_DATA) self._check_uuid(opaque_obj_result.uuid.value, str) @@ -1149,7 +1150,7 @@ class TestIntegration(TestCase): expected = ResultReason opaque_obj_observed = \ - type(opaque_obj_result_destroyed_result.result_reason.enum) + type(opaque_obj_result_destroyed_result.result_reason.value) self.assertEqual(expected, opaque_obj_observed) diff --git a/kmip/tests/integration/services/test_kmip_client.py b/kmip/tests/integration/services/test_kmip_client.py index 58dbdf7..9dbefd3 100644 --- a/kmip/tests/integration/services/test_kmip_client.py +++ b/kmip/tests/integration/services/test_kmip_client.py @@ -102,9 +102,9 @@ class TestKMIPClientIntegration(TestCase): def test_create(self): result = self._create_symmetric_key() - self._check_result_status(result.result_status.enum, ResultStatus, + self._check_result_status(result.result_status.value, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(result.object_type.enum, ObjectType, + self._check_object_type(result.object_type.value, ObjectType, ObjectType.SYMMETRIC_KEY) self._check_uuid(result.uuid.value, str) @@ -126,9 +126,9 @@ class TestKMIPClientIntegration(TestCase): result = self.client.get(uuid=uuid, credential=credential) - self._check_result_status(result.result_status.enum, ResultStatus, + self._check_result_status(result.result_status.value, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(result.object_type.enum, ObjectType, + self._check_object_type(result.object_type.value, ObjectType, ObjectType.SYMMETRIC_KEY) self._check_uuid(result.uuid.value, str) @@ -151,9 +151,9 @@ class TestKMIPClientIntegration(TestCase): # Verify the secret was created result = self.client.get(uuid=uuid, credential=credential) - self._check_result_status(result.result_status.enum, ResultStatus, + self._check_result_status(result.result_status.value, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(result.object_type.enum, ObjectType, + self._check_object_type(result.object_type.value, ObjectType, ObjectType.SYMMETRIC_KEY) self._check_uuid(result.uuid.value, str) @@ -166,24 +166,24 @@ class TestKMIPClientIntegration(TestCase): # Destroy the SYMMETRIC_KEY object result = self.client.destroy(uuid, credential) - self._check_result_status(result.result_status.enum, ResultStatus, + self._check_result_status(result.result_status.value, ResultStatus, ResultStatus.SUCCESS) self._check_uuid(result.uuid.value, str) # Verify the secret was destroyed result = self.client.get(uuid=uuid, credential=credential) - self._check_result_status(result.result_status.enum, ResultStatus, + self._check_result_status(result.result_status.value, ResultStatus, ResultStatus.OPERATION_FAILED) expected = ResultReason - observed = type(result.result_reason.enum) + observed = type(result.result_reason.value) message = utils.build_er_error(result.result_reason.__class__, 'type', expected, observed) self.assertEqual(expected, observed, message) expected = ResultReason.ITEM_NOT_FOUND - observed = result.result_reason.enum + observed = result.result_reason.value message = utils.build_er_error(result.result_reason.__class__, 'value', expected, observed) self.assertEqual(expected, observed, message) @@ -228,7 +228,7 @@ class TestKMIPClientIntegration(TestCase): result = self.client.register(object_type, template_attribute, secret, credential) - self._check_result_status(result.result_status.enum, ResultStatus, + self._check_result_status(result.result_status.value, ResultStatus, ResultStatus.SUCCESS) self._check_uuid(result.uuid.value, str) @@ -241,9 +241,9 @@ class TestKMIPClientIntegration(TestCase): uuid = result.uuid.value result = self.client.get(uuid=uuid, credential=credential) - self._check_result_status(result.result_status.enum, ResultStatus, + self._check_result_status(result.result_status.value, ResultStatus, ResultStatus.SUCCESS) - self._check_object_type(result.object_type.enum, ObjectType, + self._check_object_type(result.object_type.value, ObjectType, ObjectType.SYMMETRIC_KEY) self._check_uuid(result.uuid.value, str) diff --git a/kmip/tests/unit/core/attributes/test_attributes.py b/kmip/tests/unit/core/attributes/test_attributes.py index d812eb3..7cd63fc 100644 --- a/kmip/tests/unit/core/attributes/test_attributes.py +++ b/kmip/tests/unit/core/attributes/test_attributes.py @@ -154,8 +154,8 @@ class TestHashingAlgorithm(TestCase): hashing_algorithm = HashingAlgorithm(value) msg = "expected {0}, observed {1}".format( - value, hashing_algorithm.enum) - self.assertEqual(value, hashing_algorithm.enum, msg) + value, hashing_algorithm.value) + self.assertEqual(value, hashing_algorithm.value, msg) else: self.assertRaises(TypeError, HashingAlgorithm, value) @@ -205,8 +205,8 @@ class TestCertificateType(TestCase): certificate_type = CertificateType(value) msg = "expected {0}, observed {1}".format( - value, certificate_type.enum) - self.assertEqual(value, certificate_type.enum, msg) + value, certificate_type.value) + self.assertEqual(value, certificate_type.value, msg) else: self.assertRaises(TypeError, CertificateType, value) diff --git a/kmip/tests/unit/core/attributes/test_digest.py b/kmip/tests/unit/core/attributes/test_digest.py index 3087cf5..32e6067 100644 --- a/kmip/tests/unit/core/attributes/test_digest.py +++ b/kmip/tests/unit/core/attributes/test_digest.py @@ -337,42 +337,26 @@ class TestDigest(TestCase): def test_repr(self): """ Test that the representation of a Digest object with data is formatted - properly and can be used by eval to create a new Digest object - identical to the original. + properly. """ + hashing_algorithm = HashingAlgorithm(HashingAlgorithmEnum.MD5) + digest_value = DigestValue(b'\x00\x01\x02\x03') + key_format_type = KeyFormatType(KeyFormatTypeEnum.RAW) digest = Digest( - hashing_algorithm=HashingAlgorithm(HashingAlgorithmEnum.MD5), - digest_value=DigestValue(b'\x00\x01\x02\x03'), - key_format_type=KeyFormatType(KeyFormatTypeEnum.RAW)) - byte_value = b'\x00\x01\x02\x03' + hashing_algorithm=hashing_algorithm, + digest_value=digest_value, + key_format_type=key_format_type) - expected = "Digest(" - expected += "hashing_algorithm=HashingAlgorithm(" - expected += "value=HashingAlgorithm.MD5), " - expected += "digest_value=DigestValue(" - expected += "value={0}), ".format(repr(byte_value)) - expected += "key_format_type=KeyFormatType(" - expected += "value=KeyFormatType.RAW))" + hashing_algorithm = "hashing_algorithm={0}".format( + repr(hashing_algorithm)) + digest_value = "digest_value={0}".format(repr(digest_value)) + key_format_type = "key_format_type={0}".format(repr(key_format_type)) + + expected = "Digest({0}, {1}, {2})".format( + hashing_algorithm, digest_value, key_format_type) observed = repr(digest) - msg = "expected {0}, observed {1}".format(expected, observed) - self.assertEqual(expected, observed, msg) - - # Instead of using eval(repr(digest)), we need to use a manual string, - # eval(manual), due to the name collisions of the HashingAlgorithm - # and KeyFormatType objects and enumerations. - manual = "Digest(" - manual += "hashing_algorithm=HashingAlgorithm(" - manual += "value=HashingAlgorithmEnum.MD5), " - manual += "digest_value=DigestValue(" - manual += "value={0}), ".format(repr(byte_value)) - manual += "key_format_type=KeyFormatType(" - manual += "value=KeyFormatTypeEnum.RAW))" - - expected = digest - observed = eval(manual) - - msg = "expected {0}, observed {1}".format(expected, observed) + msg = "expected:\n{0},\nobserved:\n{1}".format(expected, observed) self.assertEqual(expected, observed, msg) def _test_str(self, value, expected): diff --git a/kmip/tests/unit/core/messages/test_messages.py b/kmip/tests/unit/core/messages/test_messages.py index 5145557..abb0761 100644 --- a/kmip/tests/unit/core/messages/test_messages.py +++ b/kmip/tests/unit/core/messages/test_messages.py @@ -226,9 +226,9 @@ class TestRequestMessage(TestCase): msg.format(contents.Operation, type(operation))) msg = "Bad operation value: expected {0}, received {1}" - self.assertEqual(enums.Operation.CREATE, operation.enum, + self.assertEqual(enums.Operation.CREATE, operation.value, msg.format(enums.Operation.CREATE, - operation.enum)) + operation.value)) request_payload = batch_item.request_payload msg = "Bad request payload type: expected {0}, received {1}" @@ -243,9 +243,9 @@ class TestRequestMessage(TestCase): msg.format(attr.ObjectType, type(object_type))) msg = "Bad object type value: expected {0}, received {1}" - self.assertEqual(enums.ObjectType.SYMMETRIC_KEY, object_type.enum, + self.assertEqual(enums.ObjectType.SYMMETRIC_KEY, object_type.value, msg.format(enums.ObjectType.SYMMETRIC_KEY, - object_type.enum)) + object_type.value)) template_attribute = request_payload.template_attribute msg = "Bad template attribute type: expected {0}, received {1}" @@ -284,11 +284,11 @@ class TestRequestMessage(TestCase): self.assertIsInstance(attribute_value, exp_type, self.msg.format('attribute value', 'type', exp_type, rcv_type)) - self.assertEquals(attribute_value.enum, + self.assertEquals(attribute_value.value, enums.CryptographicAlgorithm.AES, self.msg.format('cryptographic algorithm', 'value', enums.CryptographicAlgorithm.AES, - attribute_value.enum)) + attribute_value.value)) attribute_b = attributes[1] self.assertIsInstance(attribute_b, objects.Attribute, @@ -455,9 +455,9 @@ class TestRequestMessage(TestCase): msg.format(contents.Operation, type(operation))) msg = "Bad operation value: expected {0}, received {1}" - self.assertEqual(enums.Operation.GET, operation.enum, + self.assertEqual(enums.Operation.GET, operation.value, msg.format(enums.Operation.GET, - operation.enum)) + operation.value)) request_payload = batch_item.request_payload msg = "Bad request payload type: expected {0}, received {1}" @@ -572,7 +572,7 @@ class TestRequestMessage(TestCase): type(operation))) msg = "Bad operation value: expected {0}, received {1}" exp_value = enums.Operation.DESTROY - rcv_value = operation.enum + rcv_value = operation.value self.assertEqual(exp_value, rcv_value, msg.format(exp_value, rcv_value)) @@ -689,7 +689,7 @@ class TestRequestMessage(TestCase): type(operation))) msg = "Bad operation value: expected {0}, received {1}" exp_value = enums.Operation.REGISTER - rcv_value = operation.enum + rcv_value = operation.value self.assertEqual(exp_value, rcv_value, msg.format(exp_value, rcv_value)) @@ -707,7 +707,7 @@ class TestRequestMessage(TestCase): type(object_type))) msg = "Bad object type value: expected {0}, received {1}" exp_value = enums.ObjectType.TEMPLATE - rcv_value = object_type.enum + rcv_value = object_type.value self.assertEqual(exp_value, rcv_value, msg.format(exp_value, rcv_value)) @@ -888,7 +888,7 @@ class TestRequestMessage(TestCase): msg = "Bad operation value: expected {0}, received {1}" exp_value = enums.Operation.LOCATE - rcv_value = operation.enum + rcv_value = operation.value self.assertEqual(exp_value, rcv_value, msg.format(exp_value, rcv_value)) @@ -932,10 +932,12 @@ class TestRequestMessage(TestCase): self.assertIsInstance(attribute_value, exp_type, self.msg.format('attribute value', 'type', exp_type, rcv_type)) - self.assertEquals(attribute_value.enum, enums.ObjectType.SYMMETRIC_KEY, - self.msg.format('ObjectType', 'value', - enums.ObjectType.SYMMETRIC_KEY, - attribute_value.enum)) + self.assertEquals( + attribute_value.value, + enums.ObjectType.SYMMETRIC_KEY, + self.msg.format( + 'ObjectType', 'value', enums.ObjectType.SYMMETRIC_KEY, + attribute_value.value)) attribute_b = attributes[1] self.assertIsInstance(attribute_b, objects.Attribute, @@ -1125,20 +1127,20 @@ class TestResponseMessage(TestCase): self.msg.format('operation', 'type', contents.Operation, type(operation))) - self.assertEqual(enums.Operation.CREATE, operation.enum, + self.assertEqual(enums.Operation.CREATE, operation.value, self.msg.format('operation', 'value', enums.Operation.CREATE, - operation.enum)) + operation.value)) result_status = batch_item.result_status self.assertIsInstance(result_status, contents.ResultStatus, self.msg.format('result status', 'type', contents.ResultStatus, type(result_status))) - self.assertEqual(enums.ResultStatus.SUCCESS, result_status.enum, + self.assertEqual(enums.ResultStatus.SUCCESS, result_status.value, self.msg.format('result status', 'value', enums.ResultStatus.SUCCESS, - result_status.enum)) + result_status.value)) response_payload = batch_item.response_payload exp_type = create.CreateResponsePayload @@ -1152,10 +1154,10 @@ class TestResponseMessage(TestCase): self.msg.format('object type', 'type', attr.ObjectType, type(object_type))) - self.assertEqual(enums.ObjectType.SYMMETRIC_KEY, object_type.enum, + self.assertEqual(enums.ObjectType.SYMMETRIC_KEY, object_type.value, self.msg.format('object type', 'value', enums.ObjectType.SYMMETRIC_KEY, - object_type.enum)) + object_type.value)) unique_identifier = response_payload.unique_identifier value = 'fb4b5b9c-6188-4c63-8142-fe9c328129fc' @@ -1274,20 +1276,20 @@ class TestResponseMessage(TestCase): self.msg.format('operation', 'type', contents.Operation, type(operation))) - self.assertEqual(enums.Operation.GET, operation.enum, + self.assertEqual(enums.Operation.GET, operation.value, self.msg.format('operation', 'value', enums.Operation.GET, - operation.enum)) + operation.value)) result_status = batch_item.result_status self.assertIsInstance(result_status, contents.ResultStatus, self.msg.format('result status', 'type', contents.ResultStatus, type(result_status))) - self.assertEqual(enums.ResultStatus.SUCCESS, result_status.enum, + self.assertEqual(enums.ResultStatus.SUCCESS, result_status.value, self.msg.format('result status', 'value', enums.ResultStatus.SUCCESS, - result_status.enum)) + result_status.value)) response_payload = batch_item.response_payload exp_type = get.GetResponsePayload @@ -1301,10 +1303,10 @@ class TestResponseMessage(TestCase): self.msg.format('object type', 'type', attr.ObjectType, type(object_type))) - self.assertEqual(enums.ObjectType.SYMMETRIC_KEY, object_type.enum, + self.assertEqual(enums.ObjectType.SYMMETRIC_KEY, object_type.value, self.msg.format('object type', 'value', enums.ObjectType.SYMMETRIC_KEY, - object_type.enum)) + object_type.value)) unique_identifier = response_payload.unique_identifier value = '49a1ca88-6bea-4fb2-b450-7e58802c3038' @@ -1360,7 +1362,7 @@ class TestResponseMessage(TestCase): self.msg.format('cryptographic_algorithm', 'type', exp_type, rcv_type)) exp = enums.CryptographicAlgorithm.TRIPLE_DES - obs = cryptographic_algorithm.enum + obs = cryptographic_algorithm.value self.assertEqual(exp, obs, self.msg.format('cryptographic_algorithm', 'value', exp, obs)) @@ -1517,7 +1519,7 @@ class TestResponseMessage(TestCase): type(operation))) msg = "Bad operation value: expected {0}, received {1}" exp_value = enums.Operation.DESTROY - rcv_value = operation.enum + rcv_value = operation.value self.assertEqual(exp_value, rcv_value, msg.format(exp_value, rcv_value)) @@ -1526,10 +1528,10 @@ class TestResponseMessage(TestCase): self.msg.format('result status', 'type', contents.ResultStatus, type(result_status))) - self.assertEqual(enums.ResultStatus.SUCCESS, result_status.enum, + self.assertEqual(enums.ResultStatus.SUCCESS, result_status.value, self.msg.format('result status', 'value', enums.ResultStatus.SUCCESS, - result_status.enum)) + result_status.value)) response_payload = batch_item.response_payload msg = "Bad response payload type: expected {0}, received {1}" @@ -1660,7 +1662,7 @@ class TestResponseMessage(TestCase): type(operation))) msg = "Bad operation value: expected {0}, received {1}" exp_value = enums.Operation.REGISTER - rcv_value = operation.enum + rcv_value = operation.value self.assertEqual(exp_value, rcv_value, msg.format(exp_value, rcv_value)) @@ -1669,10 +1671,10 @@ class TestResponseMessage(TestCase): self.msg.format('result status', 'type', contents.ResultStatus, type(result_status))) - self.assertEqual(enums.ResultStatus.SUCCESS, result_status.enum, + self.assertEqual(enums.ResultStatus.SUCCESS, result_status.value, self.msg.format('result status', 'value', enums.ResultStatus.SUCCESS, - result_status.enum)) + result_status.value)) response_payload = batch_item.response_payload msg = "Bad response payload type: expected {0}, received {1}" diff --git a/kmip/tests/unit/core/misc/test_misc.py b/kmip/tests/unit/core/misc/test_misc.py index 6becab3..508c893 100644 --- a/kmip/tests/unit/core/misc/test_misc.py +++ b/kmip/tests/unit/core/misc/test_misc.py @@ -89,8 +89,8 @@ class TestQueryFunction(TestCase): query_function = QueryFunction(value) msg = "expected {0}, observed {1}".format( - value, query_function.enum) - self.assertEqual(value, query_function.enum, msg) + value, query_function.value) + self.assertEqual(value, query_function.value, msg) else: self.assertRaises(TypeError, QueryFunction, value) @@ -184,8 +184,8 @@ class TestKeyFormatType(TestCase): key_format_type = KeyFormatType(value) msg = "expected {0}, observed {1}".format( - value, key_format_type.enum) - self.assertEqual(value, key_format_type.enum, msg) + value, key_format_type.value) + self.assertEqual(value, key_format_type.value, msg) else: self.assertRaises(TypeError, KeyFormatType, value) diff --git a/kmip/tests/unit/core/primitives/test_enumeration.py b/kmip/tests/unit/core/primitives/test_enumeration.py index 4681b1a..686ad69 100644 --- a/kmip/tests/unit/core/primitives/test_enumeration.py +++ b/kmip/tests/unit/core/primitives/test_enumeration.py @@ -13,119 +13,271 @@ # License for the specific language governing permissions and limitations # under the License. +import enum as enumeration import testtools from kmip.core import enums -from kmip.core import errors +from kmip.core import exceptions from kmip.core import primitives from kmip.core import utils +# flake8: noqa +class DummyEnumeration(enumeration.Enum): + SMALL = primitives.Enumeration.MIN + TOO_SMALL = primitives.Enumeration.MIN - 1 + LARGE = primitives.Enumeration.MAX + TOO_LARGE = primitives.Enumeration.MAX + 1 + INVALID = 'invalid' + + class TestEnumeration(testtools.TestCase): def setUp(self): super(TestEnumeration, self).setUp() - self.stream = utils.BytearrayStream() - primitives.Enumeration.ENUM_TYPE = enums.Types - self.bad_type = errors.ErrorStrings.BAD_EXP_RECV.format( - 'primitives.Enumeration.{0}', 'type', '{1}', '{2}') - self.bad_value = errors.ErrorStrings.BAD_EXP_RECV.format( - 'primitives.Enumeration.{0}', 'value', '{1}', '{2}') - self.bad_write = errors.ErrorStrings.BAD_EXP_RECV.format( - 'primitives.Enumeration', 'write', '{0} bytes', '{1} bytes') - self.bad_encoding = errors.ErrorStrings.BAD_ENCODING.format( - 'primitives.Enumeration', 'write') + + self.encoding = ( + b'\x42\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00' + b'\x00') + self.encoding_bad_length = ( + b'\x42\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + b'\x00') + self.encoding_bad_padding = ( + b'\x42\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00' + b'\xFF') def tearDown(self): super(TestEnumeration, self).tearDown() def test_init(self): - e = primitives.Enumeration(enums.Types.DEFAULT) - - self.assertIsInstance(e.enum, enums.Types, - self.bad_type.format('enum', enums.Types, - type(e.enum))) - self.assertEqual( - enums.Types.DEFAULT, e.enum, - self.bad_value.format('enum', enums.Types.DEFAULT, e.enum)) - - default = enums.Types.DEFAULT - self.assertEqual(default.value, e.value, - self.bad_value.format('value', default.value, - e.value)) + """ + Test that an Enumeration can be instantiated. + """ + enum = primitives.Enumeration( + DummyEnumeration, DummyEnumeration.SMALL, + enums.Tags.ACTIVATION_DATE) + self.assertEqual(DummyEnumeration, enum.enum) + self.assertEqual(DummyEnumeration.SMALL, enum.value) + self.assertEqual(enums.Tags.ACTIVATION_DATE, enum.tag) def test_init_unset(self): - e = primitives.Enumeration() + """ + Test that an Enumeration can be instantiated with no input. + """ + enum = primitives.Enumeration(DummyEnumeration) + self.assertEqual(DummyEnumeration, enum.enum) + self.assertEqual(None, enum.value) + self.assertEqual(enums.Tags.DEFAULT, enum.tag) - self.assertEqual(None, e.enum, - self.bad_value.format('enum', None, e.enum)) - self.assertEqual(0, e.value, - self.bad_value.format('value', 0, e.value)) + def test_validate_on_invalid_enum_type(self): + """ + Test that a TypeError is thrown on input of invalid enum type + (e.g., str). + """ + args = ['invalid'] + kwargs = {'value': enums.Tags.DEFAULT} + self.assertRaises(TypeError, primitives.Enumeration, *args, **kwargs) - def test_validate_on_valid(self): - e = primitives.Enumeration() - e.enum = enums.Types.DEFAULT + def test_validate_on_invalid_enum_value_type(self): + """ + Test that a TypeError is thrown on input of invalid enum value type. + """ + args = [DummyEnumeration] + kwargs = {'value': enums.Tags.DEFAULT} + self.assertRaises(TypeError, primitives.Enumeration, *args, **kwargs) - # Check no exception thrown - e.validate() + def test_validate_on_invalid_value_type(self): + """ + Test that a TypeError is thrown on input of invalid value type + (e.g., str). + """ + args = [DummyEnumeration] + kwargs = {'value': DummyEnumeration.INVALID} + self.assertRaises(TypeError, primitives.Enumeration, *args, **kwargs) - def test_validate_on_valid_unset(self): - e = primitives.Enumeration() + def test_validate_on_invalid_value_too_big(self): + """ + Test that a ValueError is thrown on input that is too large. + """ + args = [DummyEnumeration] + kwargs = {'value': DummyEnumeration.TOO_LARGE} + self.assertRaises(ValueError, primitives.Enumeration, *args, **kwargs) - # Check no exception thrown - e.validate() - - def test_validate_on_invalid_type(self): - e = primitives.Enumeration() - e.enum = 0 - - self.assertRaises(TypeError, e.validate) + def test_validate_on_invalid_value_too_small(self): + """ + Test that a ValueError is thrown on input that is too small. + """ + args = [DummyEnumeration] + kwargs = {'value': DummyEnumeration.TOO_SMALL} + self.assertRaises(ValueError, primitives.Enumeration, *args, **kwargs) def test_read(self): - encoding = ( - b'\x42\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00' - b'\x00') - self.stream = utils.BytearrayStream(encoding) - e = primitives.Enumeration() - e.read(self.stream) + """ + Test that an Enumeration can be read from a byte stream. + """ + stream = utils.BytearrayStream(self.encoding) + enum = primitives.Enumeration(DummyEnumeration) + enum.read(stream) + self.assertEqual(DummyEnumeration.SMALL, enum.value) - self.assertIsInstance(e.enum, enums.Types, - self.bad_type.format('enum', enums.Types, - type(e.enum))) - self.assertEqual(enums.Types.DEFAULT, e.enum, - self.bad_value.format('enum', enums.Types.DEFAULT, - type(e.enum))) - default = enums.Types.DEFAULT - self.assertEqual(default.value, e.value, - self.bad_value.format('value', default.value, - e.value)) + def test_read_on_invalid_length(self): + """ + Test that an InvalidPrimitiveLength exception is thrown when attempting + to decode an Enumeration with an invalid length. + """ + stream = utils.BytearrayStream(self.encoding_bad_length) + enum = primitives.Enumeration(enums.Tags) + + self.assertRaises(exceptions.InvalidPrimitiveLength, enum.read, stream) + + def test_read_on_invalid_padding(self): + """ + Test that an InvalidPrimitiveLength exception is thrown when attempting + to decode an Enumeration with invalid padding bytes. + """ + stream = utils.BytearrayStream(self.encoding_bad_padding) + enum = primitives.Enumeration(enums.Types) + + self.assertRaises(exceptions.InvalidPaddingBytes, enum.read, stream) def test_write(self): - encoding = ( - b'\x42\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00' - b'\x00') - e = primitives.Enumeration(enums.Types.DEFAULT) - e.write(self.stream) - - result = self.stream.read() - len_exp = len(encoding) - len_rcv = len(result) - - self.assertEqual(len_exp, len_rcv, self.bad_write.format(len_exp, - len_rcv)) - self.assertEqual(encoding, result, self.bad_encoding) - - def test_write_unsigned(self): """ - Test that a large primitives.Enumeration value is written correctly as - an unsigned integer. + Test that an Enumeration can be written to a byte stream. """ - encoding = ( - b'\x42\x00\x00\x05\x00\x00\x00\x04\x80\x00\x00\x00\x00\x00\x00' - b'\x00') - e = primitives.Enumeration(enums.OpaqueDataType.NONE) - e.write(self.stream) - result = self.stream.read() + stream = utils.BytearrayStream() + enum = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + enum.write(stream) - self.assertEqual(len(encoding), len(result)) - self.assertEqual(encoding, result) + result = stream.read() + self.assertEqual(len(self.encoding), len(result)) + self.assertEqual(self.encoding, result) + + def test_repr(self): + """ + Test that the representation of an Enumeration is formatted properly. + """ + enum = "enum={0}".format(DummyEnumeration.__name__) + value = "value={0}".format(DummyEnumeration.SMALL) + tag = "tag={0}".format(enums.Tags.DEFAULT) + r = "Enumeration({0}, {1}, {2})".format(enum, value, tag) + + enum = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + self.assertEqual(r, repr(enum)) + + def test_str(self): + """ + Test that the string representation of an Enumeration is formatted + properly. + """ + enum = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + self.assertEqual(str(DummyEnumeration.SMALL), str(enum.value)) + + def test_equal_on_equal(self): + """ + Test that the equality operator returns True when comparing two + Enumerations. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + + self.assertTrue(a == b) + self.assertTrue(b == a) + + def test_equal_on_equal_and_empty(self): + """ + Test that the equality operator returns True when comparing two + Enumerations. + """ + a = primitives.Enumeration(DummyEnumeration) + b = primitives.Enumeration(DummyEnumeration) + + self.assertTrue(a == b) + self.assertTrue(b == a) + + def test_equal_on_not_equal(self): + """ + Test that the equality operator returns False when comparing two + Enumerations with different values. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = primitives.Enumeration(DummyEnumeration, DummyEnumeration.LARGE) + + self.assertFalse(a == b) + self.assertFalse(b == a) + + def test_equal_on_not_equal_enum(self): + """ + Test that the equality operator returns False when comparing two + Enumerations with different enum types. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = primitives.Enumeration(enums.Tags, enums.Tags.DEFAULT) + + self.assertFalse(a == b) + self.assertFalse(b == a) + + def test_equal_on_type_mismatch(self): + """ + Test that the equality operator returns False when comparing a + Enumeration to a non-Enumeration object. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = 'invalid' + + 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 Enumerations with the same values. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + + self.assertFalse(a != b) + self.assertFalse(b != a) + + def test_not_equal_on_equal_and_empty(self): + """ + Test that the inequality operator returns False when comparing + two Enumerations. + """ + a = primitives.Enumeration(DummyEnumeration) + b = primitives.Enumeration(DummyEnumeration) + + 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 + Enumerations with different values. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = primitives.Enumeration(DummyEnumeration, DummyEnumeration.LARGE) + + self.assertTrue(a != b) + self.assertTrue(b != a) + + def test_not_equal_on_not_equal_enum(self): + """ + Test that the equality operator returns True when comparing two + Enumerations with different enum types. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = primitives.Enumeration(enums.Tags, enums.Tags.DEFAULT) + + 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 a + Enumeration to a non-Enumeration object. + """ + a = primitives.Enumeration(DummyEnumeration, DummyEnumeration.SMALL) + b = 'invalid' + + self.assertTrue(a != b) + self.assertTrue(b != a) diff --git a/kmip/tests/unit/core/test_server.py b/kmip/tests/unit/core/test_server.py index 65c7d23..30a2361 100644 --- a/kmip/tests/unit/core/test_server.py +++ b/kmip/tests/unit/core/test_server.py @@ -66,7 +66,7 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.create(obj_type, template_attribute) self.assertNotEqual(None, res, 'result is None') - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') def test_create_no_length(self): @@ -76,7 +76,7 @@ class TestKMIPServer(TestCase): res = self.kmip.create(obj_type, template_attribute) self.assertNotEqual(None, res, 'result is None') attrs = res.template_attribute.attributes - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') self.assertTrue(self._check_attr_exists(attributes[2], attrs), 'length attribute not returned') @@ -87,8 +87,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.create(obj_type, template_attribute) self.assertNotEqual(None, res, 'result is None') - self.assertEqual(ResultStatus.OPERATION_FAILED, res.result_status.enum, - 'result status did not return failed') + self.assertEqual( + ResultStatus.OPERATION_FAILED, + res.result_status.value, + 'result status did not return failed') def test_create_no_usage_mask(self): obj_type = ObjectType(ObjectTypeEnum.SYMMETRIC_KEY) @@ -96,8 +98,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.create(obj_type, template_attribute) self.assertNotEqual(None, res, 'result is None') - self.assertEqual(ResultStatus.OPERATION_FAILED, res.result_status.enum, - 'result status did not return failed') + self.assertEqual( + ResultStatus.OPERATION_FAILED, + res.result_status.value, + 'result status did not return failed') def test_register(self): obj_type = ObjectType(ObjectTypeEnum.SYMMETRIC_KEY) @@ -106,7 +110,7 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertNotEqual(None, res, 'result is None') - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') def test_register_attrs_in_key_value(self): @@ -119,7 +123,7 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertNotEqual(None, res, 'result is None') - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') def test_register_attrs_in_template(self): @@ -132,7 +136,7 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertNotEqual(None, res, 'result is None') - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') def test_register_no_alg(self): @@ -143,10 +147,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_alg_in_key_value_and_key_block(self): @@ -157,10 +161,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INDEX_OUT_OF_BOUNDS, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_alg_in_template_and_key_block(self): @@ -170,10 +174,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INDEX_OUT_OF_BOUNDS, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_alg_in_template_and_key_value(self): @@ -185,10 +189,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INDEX_OUT_OF_BOUNDS, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_invalid_alg(self): @@ -222,10 +226,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INVALID_FIELD, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_no_length(self): @@ -236,10 +240,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_length_in_key_value_and_key_block(self): @@ -250,10 +254,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INDEX_OUT_OF_BOUNDS, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_length_in_template_and_key_block(self): @@ -263,10 +267,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INDEX_OUT_OF_BOUNDS, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_length_in_template_and_key_value(self): @@ -278,10 +282,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INDEX_OUT_OF_BOUNDS, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_invalid_length(self): @@ -294,10 +298,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INVALID_FIELD, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_no_usage_mask(self): @@ -308,10 +312,10 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.register(obj_type, template_attribute, key) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_no_object_type(self): @@ -322,10 +326,10 @@ class TestKMIPServer(TestCase): res = self.kmip.register(obj_type, template_attribute, key) self.assertNotEqual(None, res, 'result is None') self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_unsupported_object_type(self): @@ -344,10 +348,10 @@ class TestKMIPServer(TestCase): res = self.kmip.register(obj_type, template_attribute, key) self.assertNotEqual(None, res, 'result is None') self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INVALID_FIELD, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_register_object_type_mismatch(self): @@ -366,23 +370,23 @@ class TestKMIPServer(TestCase): res = self.kmip.register(obj_type, template_attribute, key) self.assertNotEqual(None, res, 'result is None') self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.INVALID_FIELD, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_get(self): uuid = self._create() key_format_type = KeyFormatType(KeyFormatTypeEnum.RAW) res = self.kmip.get(uuid, key_format_type) - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') def test_get_no_key_format_type(self): uuid = self._create() res = self.kmip.get(uuid, None) - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') def test_get_unknown(self): @@ -391,17 +395,18 @@ class TestKMIPServer(TestCase): key_format_type = KeyFormatType(KeyFormatTypeEnum.RAW) res = self.kmip.get(uuid, key_format_type) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_get_no_uuid(self): self._create() key_format_type = KeyFormatType(KeyFormatTypeEnum.RAW) res = self.kmip.get(None, key_format_type) - self.assertEqual(ResultStatus.OPERATION_FAILED, res.result_status.enum, + self.assertEqual(ResultStatus.OPERATION_FAILED, + res.result_status.value, 'result status did not return failed') def test_get_with_key_compression(self): @@ -410,36 +415,37 @@ class TestKMIPServer(TestCase): key_compression = KeyCompressionType(KeyCompressionTypeEnum. EC_PUBLIC_KEY_TYPE_UNCOMPRESSED) res = self.kmip.get(uuid, key_format_type, key_compression) - self.assertEqual(ResultStatus.OPERATION_FAILED, res.result_status.enum, + self.assertEqual(ResultStatus.OPERATION_FAILED, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.KEY_COMPRESSION_TYPE_NOT_SUPPORTED, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_destroy(self): uuid = self._create() key_format_type = KeyFormatType(KeyFormatTypeEnum.RAW) res = self.kmip.get(uuid, key_format_type) - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') res = self.kmip.destroy(uuid) - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') res = self.kmip.destroy(uuid) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_destroy_no_uuid(self): res = self.kmip.destroy(None) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def test_destroy_unknown(self): @@ -448,14 +454,14 @@ class TestKMIPServer(TestCase): key_format_type = KeyFormatType(KeyFormatTypeEnum.RAW) res = self.kmip.get(uuid, key_format_type) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') res = self.kmip.destroy(uuid) self.assertEqual(ResultStatus.OPERATION_FAILED, - res.result_status.enum, + res.result_status.value, 'result status did not return failed') self.assertEqual(ResultReason.ITEM_NOT_FOUND, - res.result_reason.enum, + res.result_reason.value, 'result reason did not match') def _create(self): @@ -464,7 +470,7 @@ class TestKMIPServer(TestCase): template_attribute = TemplateAttribute(attributes=attributes) res = self.kmip.create(obj_type, template_attribute) self.assertNotEqual(None, res, 'result is None') - self.assertEqual(ResultStatus.SUCCESS, res.result_status.enum, + self.assertEqual(ResultStatus.SUCCESS, res.result_status.value, 'result status did not return success') return res.uuid @@ -530,5 +536,7 @@ class TestKMIPServer(TestCase): attrs = [nameattr] res = self.kmip.locate(attributes=attrs) - self.assertEqual(ResultStatus.OPERATION_FAILED, res.result_status.enum, - 'locate result status did not return success') + self.assertEqual( + ResultStatus.OPERATION_FAILED, + res.result_status.value, + 'locate result status did not return success') diff --git a/kmip/tests/unit/pie/test_factory.py b/kmip/tests/unit/pie/test_factory.py index 1452d84..3939289 100644 --- a/kmip/tests/unit/pie/test_factory.py +++ b/kmip/tests/unit/pie/test_factory.py @@ -243,8 +243,8 @@ class TestObjectFactory(testtools.TestCase): pie_key = self.factory.convert(core_key) self.assertIsInstance(pie_key, pobjects.SymmetricKey) self._test_pie_key( - pie_key, algorithm.enum, length.value, self.symmetric_bytes, - format_type.enum) + pie_key, algorithm.value, length.value, self.symmetric_bytes, + format_type.value) def test_convert_public_key_pie_to_core(self): """ @@ -282,8 +282,8 @@ class TestObjectFactory(testtools.TestCase): pie_key = self.factory.convert(core_key) self.assertIsInstance(pie_key, pobjects.PublicKey) self._test_pie_key( - pie_key, algorithm.enum, length.value, self.public_bytes, - format_type.enum) + pie_key, algorithm.value, length.value, self.public_bytes, + format_type.value) def test_convert_private_key_pie_to_core(self): """ @@ -321,8 +321,8 @@ class TestObjectFactory(testtools.TestCase): pie_key = self.factory.convert(core_key) self.assertIsInstance(pie_key, pobjects.PrivateKey) self._test_pie_key( - pie_key, algorithm.enum, length.value, self.private_bytes, - format_type.enum) + pie_key, algorithm.value, length.value, self.private_bytes, + format_type.value) def test_convert_certificate_pie_to_core(self): """ @@ -333,7 +333,7 @@ class TestObjectFactory(testtools.TestCase): self.assertIsInstance(core_cert, secrets.Certificate) self.assertEqual( - pie_cert.certificate_type, core_cert.certificate_type.enum) + pie_cert.certificate_type, core_cert.certificate_type.value) self.assertEqual(pie_cert.value, core_cert.certificate_value.value) def test_convert_certificate_core_to_pie(self): @@ -346,7 +346,7 @@ class TestObjectFactory(testtools.TestCase): self.assertIsInstance(pie_cert, pobjects.X509Certificate) self.assertEqual( - core_cert.certificate_type.enum, pie_cert.certificate_type) + core_cert.certificate_type.value, pie_cert.certificate_type) self.assertEqual(core_cert.certificate_value.value, pie_cert.value) def test_convert_secret_data_pie_to_core(self): @@ -360,7 +360,7 @@ class TestObjectFactory(testtools.TestCase): self.assertIsInstance(core_secret, secrets.SecretData) - data_type = core_secret.secret_data_type.enum + data_type = core_secret.secret_data_type.value self.assertEqual(enums.SecretDataType.PASSWORD, data_type) key_block = core_secret.key_block @@ -408,7 +408,7 @@ class TestObjectFactory(testtools.TestCase): self.assertIsInstance(core_obj, secrets.OpaqueObject) - opaque_type = core_obj.opaque_data_type.enum + opaque_type = core_obj.opaque_data_type.value self.assertEqual(enums.OpaqueDataType.NONE, opaque_type) value = core_obj.opaque_data_value.value @@ -453,8 +453,8 @@ class TestObjectFactory(testtools.TestCase): self.assertIsInstance(pie_key, pobjects.SymmetricKey) self._test_pie_key( - pie_key, algorithm.enum, length.value, self.symmetric_bytes, - format_type.enum) + pie_key, algorithm.value, length.value, self.symmetric_bytes, + format_type.value) def test_build_pie_symmetric_key_on_invalid_format(self): """ @@ -503,8 +503,8 @@ class TestObjectFactory(testtools.TestCase): self.assertIsInstance(pie_key, pobjects.PublicKey) self._test_pie_key( - pie_key, algorithm.enum, length.value, self.public_bytes, - format_type.enum) + pie_key, algorithm.value, length.value, self.public_bytes, + format_type.value) def test_build_core_key(self): """ @@ -537,13 +537,13 @@ class TestObjectFactory(testtools.TestCase): key_format_type = key_block.key_format_type self.assertIsInstance(key_format_type, misc.KeyFormatType) - self.assertEqual(key_format_type.enum, format_type) + self.assertEqual(key_format_type.value, format_type) cryptographic_algorithm = key_block.cryptographic_algorithm self.assertIsInstance( cryptographic_algorithm, attributes.CryptographicAlgorithm) self.assertEqual( - cryptographic_algorithm.enum, algorithm) + cryptographic_algorithm.value, algorithm) cryptographic_length = key_block.cryptographic_length self.assertIsInstance( diff --git a/kmip/tests/unit/services/test_kmip_client.py b/kmip/tests/unit/services/test_kmip_client.py index 4016f93..082e10d 100644 --- a/kmip/tests/unit/services/test_kmip_client.py +++ b/kmip/tests/unit/services/test_kmip_client.py @@ -88,10 +88,10 @@ class TestKMIPClient(TestCase): message = utils.build_er_error(credential.__class__, 'type', cred_type, - credential.credential_type.enum, + credential.credential_type.value, 'value') self.assertEqual(CredentialType.USERNAME_AND_PASSWORD, - credential.credential_type.enum, + credential.credential_type.value, message) message = utils.build_er_error( @@ -151,7 +151,7 @@ class TestKMIPClient(TestCase): msg = base.format(Operation, operation) self.assertIsInstance(operation, Operation, msg) - operation_enum = operation.enum + operation_enum = operation.value msg = base.format(OperationEnum.CREATE_KEY_PAIR, operation_enum) self.assertEqual(OperationEnum.CREATE_KEY_PAIR, operation_enum, msg) @@ -200,7 +200,7 @@ class TestKMIPClient(TestCase): msg = base.format(Operation, operation) self.assertIsInstance(operation, Operation, msg) - operation_enum = operation.enum + operation_enum = operation.value msg = base.format(OperationEnum.REKEY_KEY_PAIR, operation_enum) self.assertEqual(OperationEnum.REKEY_KEY_PAIR, operation_enum, msg) @@ -254,7 +254,7 @@ class TestKMIPClient(TestCase): msg = base.format(Operation, operation) self.assertIsInstance(operation, Operation, msg) - operation_enum = operation.enum + operation_enum = operation.value msg = base.format(OperationEnum.QUERY, operation_enum) self.assertEqual(OperationEnum.QUERY, operation_enum, msg) @@ -290,7 +290,7 @@ class TestKMIPClient(TestCase): msg = base.format(Operation, operation) self.assertIsInstance(operation, Operation, msg) - operation_enum = operation.enum + operation_enum = operation.value msg = base.format(OperationEnum.DISCOVER_VERSIONS, operation_enum) self.assertEqual(OperationEnum.DISCOVER_VERSIONS, operation_enum, msg) @@ -323,7 +323,7 @@ class TestKMIPClient(TestCase): self.assertIsInstance(batch_item, RequestBatchItem) self.assertIsInstance(batch_item.operation, Operation) self.assertEqual( - OperationEnum.GET_ATTRIBUTE_LIST, batch_item.operation.enum) + OperationEnum.GET_ATTRIBUTE_LIST, batch_item.operation.value) self.assertIsInstance( batch_item.request_payload, get_attribute_list.GetAttributeListRequestPayload)