1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
# Copyright (c) 2015 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.
"""
Test cases for the public key class.
"""
from castellan.common import objects
from castellan.common.objects import public_key
from castellan.tests import base
from castellan.tests import utils
class PublicKeyTestCase(base.KeyTestCase):
def _create_key(self):
return public_key.PublicKey(self.algorithm,
self.bit_length,
self.encoded,
self.name,
self.created,
consumers=self.consumers)
def setUp(self):
self.algorithm = 'RSA'
self.bit_length = 2048
self.encoded = bytes(utils.get_public_key_der())
self.name = 'my key'
self.created = 1448088699
self.consumers = [{'service': 'service_test',
'resource_type': 'type_test',
'resource_id': 'id_test'}]
super(PublicKeyTestCase, self).setUp()
def test_is_not_only_metadata(self):
self.assertFalse(self.key.is_metadata_only())
def test_is_only_metadata(self):
k = public_key.PublicKey(self.algorithm,
self.bit_length,
None,
self.name,
self.created,
consumers=self.consumers)
self.assertTrue(k.is_metadata_only())
def test_get_algorithm(self):
self.assertEqual(self.algorithm, self.key.algorithm)
def test_get_bit_length(self):
self.assertEqual(self.bit_length, self.key.bit_length)
def test_get_name(self):
self.assertEqual(self.name, self.key.name)
def test_get_format(self):
self.assertEqual('SubjectPublicKeyInfo', self.key.format)
def test_get_encoded(self):
self.assertEqual(self.encoded, self.key.get_encoded())
def test_get_created(self):
self.assertEqual(self.created, self.key.created)
def test_get_consumers(self):
self.assertEqual(self.consumers, self.key.consumers)
def test_get_created_none(self):
created = None
key = public_key.PublicKey(self.algorithm,
self.bit_length,
self.encoded,
self.name,
created,
consumers=self.consumers)
self.assertEqual(created, key.created)
def test___eq__(self):
self.assertTrue(self.key == self.key)
self.assertTrue(self.key is self.key)
self.assertFalse(self.key is None)
self.assertFalse(None == self.key) # noqa: E711
other_key = public_key.PublicKey(self.algorithm,
self.bit_length,
self.encoded,
consumers=self.consumers)
self.assertTrue(self.key == other_key)
self.assertFalse(self.key is other_key)
def test___ne___none(self):
self.assertTrue(self.key is not None)
self.assertTrue(None != self.key) # noqa: E711
def test___ne___algorithm(self):
other_key = public_key.PublicKey('DSA',
self.bit_length,
self.encoded,
self.name,
consumers=self.consumers)
self.assertTrue(self.key != other_key)
def test___ne___bit_length(self):
other_key = public_key.PublicKey(self.algorithm,
4096,
self.encoded,
self.name,
consumers=self.consumers)
self.assertTrue(self.key != other_key)
def test___ne___encoded(self):
different_encoded = bytes(utils.get_public_key_der()) + b'\x00'
other_key = public_key.PublicKey(self.algorithm,
self.bit_length,
different_encoded,
self.name,
consumers=self.consumers)
self.assertTrue(self.key != other_key)
def test___ne___consumers(self):
different_consumers = [{'service': 'other_service',
'resource_type': 'other_type',
'resource_id': 'other_id'}]
other_key = public_key.PublicKey(self.algorithm,
self.bit_length,
self.encoded,
self.name,
consumers=different_consumers)
self.assertTrue(self.key is not other_key)
def test_to_and_from_dict(self):
other = objects.from_dict(self.key.to_dict())
self.assertEqual(self.key, other)
|
