tyler.durden
/
PyKMIP
mirror of https://github.com/OpenKMIP/PyKMIP.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #145 from OpenKMIP/feat/add-attribute-policy 

Adding an AttributePolicy system
This commit is contained in:
Peter Hamilton 2016-03-23 07:59:59 -04:00
parent 9e074da553 07a63c07c8
commit 840aed7107
6 changed files with 1568 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
kmip/core/messages/contents.py
View File

@ -118,6 +118,58 @@ class ProtocolVersion(Struct):
else:
return NotImplemented
def __lt__(self, other):
if isinstance(other, ProtocolVersion):
if self.protocol_version_major < other.protocol_version_major:
return True
elif self.protocol_version_major > other.protocol_version_major:
return False
elif self.protocol_version_minor < other.protocol_version_minor:
return True
else:
return False
else:
return NotImplemented
def __gt__(self, other):
if isinstance(other, ProtocolVersion):
if self.protocol_version_major > other.protocol_version_major:
return True
elif self.protocol_version_major < other.protocol_version_major:
return False
elif self.protocol_version_minor > other.protocol_version_minor:
return True
else:
return False
else:
return NotImplemented
def __le__(self, other):
if isinstance(other, ProtocolVersion):
if self.protocol_version_major < other.protocol_version_major:
return True
elif self.protocol_version_major > other.protocol_version_major:
return False
elif self.protocol_version_minor <= other.protocol_version_minor:
return True
else:
return False
else:
return NotImplemented
def __ge__(self, other):
if isinstance(other, ProtocolVersion):
if self.protocol_version_major > other.protocol_version_major:
return True
elif self.protocol_version_major < other.protocol_version_major:
return False
elif self.protocol_version_minor >= other.protocol_version_minor:
return True
else:
return False
else:
return NotImplemented
def __repr__(self):
major = self.protocol_version_major.value
minor = self.protocol_version_minor.value

28
kmip/core/primitives.py
View File

@ -231,10 +231,10 @@ class Integer(Base):
raise ValueError('integer value less than accepted min')
def __repr__(self):
return "{0}(value={1})".format(type(self).__name__, repr(self.value))
return "{0}(value={1})".format(type(self).__name__, self.value)
def __str__(self):
return "{0}".format(repr(self.value))
return str(self.value)
def __eq__(self, other):
if isinstance(other, Integer):
@ -248,6 +248,30 @@ class Integer(Base):
else:
return NotImplemented
def __lt__(self, other):
if isinstance(other, Integer):
return self.value < other.value
else:
return NotImplemented
def __gt__(self, other):
if isinstance(other, Integer):
return self.value > other.value
else:
return NotImplemented
def __le__(self, other):
if isinstance(other, Integer):
return self.__eq__(other) or self.__lt__(other)
else:
return NotImplemented
def __ge__(self, other):
if isinstance(other, Integer):
return self.__eq__(other) or self.__gt__(other)
else:
return NotImplemented
class LongInteger(Base):
"""

1148
kmip/services/server/policy.py Normal file
View File

File diff suppressed because it is too large Load Diff

72
kmip/tests/unit/core/messages/contents/test_protocol_version.py
View File

@ -169,6 +169,78 @@ class TestProtocolVersion(TestCase):
self.assertTrue(a != b)
def test_less_than(self):
"""
Test that the less than operator returns True/False when comparing
two different ProtocolVersions.
"""
a = ProtocolVersion.create(1, 0)
b = ProtocolVersion.create(1, 1)
c = ProtocolVersion.create(2, 0)
d = ProtocolVersion.create(0, 2)
self.assertTrue(a < b)
self.assertFalse(b < a)
self.assertFalse(a < a)
self.assertTrue(a < c)
self.assertFalse(c < a)
self.assertFalse(c < d)
self.assertTrue(d < c)
def test_greater_than(self):
"""
Test that the greater than operator returns True/False when
comparing two different ProtocolVersions.
"""
a = ProtocolVersion.create(1, 0)
b = ProtocolVersion.create(1, 1)
c = ProtocolVersion.create(2, 0)
d = ProtocolVersion.create(0, 2)
self.assertFalse(a > b)
self.assertTrue(b > a)
self.assertFalse(a > a)
self.assertFalse(a > c)
self.assertTrue(c > a)
self.assertTrue(c > d)
self.assertFalse(d > c)
def test_less_than_or_equal(self):
"""
Test that the less than or equal operator returns True/False when
comparing two different ProtocolVersions.
"""
a = ProtocolVersion.create(1, 0)
b = ProtocolVersion.create(1, 1)
c = ProtocolVersion.create(2, 0)
d = ProtocolVersion.create(0, 2)
self.assertTrue(a <= b)
self.assertFalse(b <= a)
self.assertTrue(a <= a)
self.assertTrue(a <= c)
self.assertFalse(c <= a)
self.assertFalse(c <= d)
self.assertTrue(d <= c)
def test_greater_than_or_equal(self):
"""
Test that the greater than or equal operator returns True/False when
comparing two different ProtocolVersions.
"""
a = ProtocolVersion.create(1, 0)
b = ProtocolVersion.create(1, 1)
c = ProtocolVersion.create(2, 0)
d = ProtocolVersion.create(0, 2)
self.assertFalse(a >= b)
self.assertTrue(b >= a)
self.assertTrue(a >= a)
self.assertFalse(a >= c)
self.assertTrue(c >= a)
self.assertTrue(c >= d)
self.assertFalse(d >= c)
def test_repr(self):
a = ProtocolVersion.create(1, 0)

156
kmip/tests/unit/core/primitives/test_integer.py
View File

@ -223,3 +223,159 @@ class TestInteger(testtools.TestCase):
self.assertEqual(len_exp, len_rcv, self.bad_write.format(len_exp,
len_rcv))
self.assertEqual(encoding, result, self.bad_encoding)
def test_repr(self):
"""
Test that the representation of an Integer is formatted properly.
"""
integer = primitives.Integer()
value = "value={0}".format(integer.value)
self.assertEqual(
"Integer({0})".format(value), repr(integer))
def test_str(self):
"""
Test that the string representation of an Integer is formatted
properly.
"""
self.assertEqual("0", str(primitives.Integer()))
def test_equal_on_equal(self):
"""
Test that the equality operator returns True when comparing two
Integers.
"""
a = primitives.Integer(1)
b = primitives.Integer(1)
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
Integers.
"""
a = primitives.Integer()
b = primitives.Integer()
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
Integers with different values.
"""
a = primitives.Integer(1)
b = primitives.Integer(2)
self.assertFalse(a == b)
self.assertFalse(b == a)
def test_equal_on_type_mismatch(self):
"""
Test that the equality operator returns False when comparing an
Integer to a non-Integer object.
"""
a = primitives.Integer()
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 Integers with the same values.
"""
a = primitives.Integer(1)
b = primitives.Integer(1)
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 Integers.
"""
a = primitives.Integer()
b = primitives.Integer()
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
Integers with different values.
"""
a = primitives.Integer(1)
b = primitives.Integer(2)
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 an
Integer to a non-Integer object.
"""
a = primitives.Integer()
b = 'invalid'
self.assertTrue(a != b)
self.assertTrue(b != a)
def test_less_than(self):
"""
Test that the less than operator returns True/False when comparing
two Integers with different values.
"""
a = primitives.Integer(1)
b = primitives.Integer(2)
self.assertTrue(a < b)
self.assertFalse(b < a)
self.assertFalse(a < a)
def test_greater_than(self):
"""
Test that the greater than operator returns True/False when comparing
two Integers with different values.
"""
a = primitives.Integer(1)
b = primitives.Integer(2)
self.assertFalse(a > b)
self.assertTrue(b > a)
self.assertFalse(b > b)
def test_less_than_or_equal(self):
"""
Test that the less than or equal operator returns True/False when
comparing two Integers with different values.
"""
a = primitives.Integer(1)
b = primitives.Integer(2)
c = primitives.Integer(1)
self.assertTrue(a <= b)
self.assertFalse(b <= c)
self.assertTrue(a <= c)
self.assertTrue(a <= a)
def test_greater_than_or_equal(self):
"""
Test that the greater than or equal operator returns True/False when
comparing two Integers with different values.
"""
a = primitives.Integer(1)
b = primitives.Integer(2)
c = primitives.Integer(1)
self.assertFalse(a >= b)
self.assertTrue(b >= c)
self.assertTrue(a >= c)
self.assertTrue(a >= a)

114
kmip/tests/unit/services/server/test_policy.py Normal file
View File

@ -0,0 +1,114 @@
# Copyright (c) 2016 The Johns Hopkins University/Applied Physics Laboratory
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import testtools
from kmip.core import enums
from kmip.core.messages import contents
from kmip.services.server import policy
class TestAttributePolicy(testtools.TestCase):
"""
A test engine for AttributePolicy.
"""
def setUp(self):
super(TestAttributePolicy, self).setUp()
def tearDown(self):
super(TestAttributePolicy, self).tearDown()
def test_init(self):
"""
Test that an AttributePolicy can be built without any errors.
"""
policy.AttributePolicy(contents.ProtocolVersion.create(1, 0))
def test_is_attribute_supported(self):
"""
Test that is_attribute_supported returns the expected results in all
cases.
"""
rules = policy.AttributePolicy(contents.ProtocolVersion.create(1, 0))
attribute_a = 'Unique Identifier'
attribute_b = 'Certificate Length'
attribute_c = 'invalid'
result = rules.is_attribute_supported(attribute_a)
self.assertTrue(result)
result = rules.is_attribute_supported(attribute_b)
self.assertFalse(result)
result = rules.is_attribute_supported(attribute_c)
self.assertFalse(result)
def test_is_attribute_deprecated(self):
"""
Test that is_attribute_deprecated returns the expected results in all
cases.
"""
rules = policy.AttributePolicy(contents.ProtocolVersion.create(1, 0))
attribute_a = 'Name'
attribute_b = 'Certificate Subject'
result = rules.is_attribute_deprecated(attribute_a)
self.assertFalse(result)
result = rules.is_attribute_deprecated(attribute_b)
self.assertFalse(result)
rules = policy.AttributePolicy(contents.ProtocolVersion.create(1, 1))
result = rules.is_attribute_deprecated(attribute_b)
self.assertTrue(result)
def test_is_attribute_applicable_to_object_type(self):
"""
Test that is_attribute_applicable_to_object_type returns the
expected results in all cases.
"""
rules = policy.AttributePolicy(contents.ProtocolVersion.create(1, 0))
attribute = 'Cryptographic Algorithm'
object_type_a = enums.ObjectType.SYMMETRIC_KEY
object_type_b = enums.ObjectType.OPAQUE_DATA
result = rules.is_attribute_applicable_to_object_type(
attribute,
object_type_a
)
self.assertTrue(result)
result = rules.is_attribute_applicable_to_object_type(
attribute,
object_type_b
)
self.assertFalse(result)
def test_is_attribute_multivalued(self):
"""
Test that is_attribute_multivalued returns the expected results in
all cases.
"""
rules = policy.AttributePolicy(contents.ProtocolVersion.create(1, 0))
attribute_a = 'Object Type'
attribute_b = 'Link'
result = rules.is_attribute_multivalued(attribute_a)
self.assertFalse(result)
result = rules.is_attribute_multivalued(attribute_b)
self.assertTrue(result)