1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
20 from snaps import file_utils
21 from snaps.config.keypair import KeypairConfig, KeypairConfigError
22 from snaps.openstack.create_keypairs import (
23 KeypairSettings, OpenStackKeypair)
24 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
25 from snaps.openstack.utils import nova_utils
27 __author__ = 'spisarski'
30 class KeypairSettingsUnitTests(unittest.TestCase):
32 Tests the construction of the KeypairSettings class
35 def test_no_params(self):
36 with self.assertRaises(KeypairConfigError):
39 def test_empty_config(self):
40 with self.assertRaises(KeypairConfigError):
41 KeypairSettings(**dict())
43 def test_small_key_size(self):
44 with self.assertRaises(KeypairConfigError):
45 KeypairSettings(name='foo', key_size=511)
47 def test_name_only(self):
48 settings = KeypairSettings(name='foo')
49 self.assertEqual('foo', settings.name)
50 self.assertEqual(1024, settings.key_size)
51 self.assertIsNone(settings.public_filepath)
52 self.assertIsNone(settings.private_filepath)
53 self.assertIsNone(settings.delete_on_clean)
55 def test_config_with_name_only(self):
56 settings = KeypairSettings(**{'name': 'foo'})
57 self.assertEqual('foo', settings.name)
58 self.assertEqual(1024, settings.key_size)
59 self.assertIsNone(settings.public_filepath)
60 self.assertIsNone(settings.private_filepath)
61 self.assertIsNone(settings.delete_on_clean)
63 def test_name_pub_only(self):
64 settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub')
65 self.assertEqual('foo', settings.name)
66 self.assertEqual(1024, settings.key_size)
67 self.assertEqual('/foo/bar.pub', settings.public_filepath)
68 self.assertIsNone(settings.private_filepath)
69 self.assertIsNone(settings.delete_on_clean)
71 def test_config_with_name_pub_only(self):
72 settings = KeypairSettings(
73 **{'name': 'foo', 'public_filepath': '/foo/bar.pub'})
74 self.assertEqual('foo', settings.name)
75 self.assertEqual(1024, settings.key_size)
76 self.assertEqual('/foo/bar.pub', settings.public_filepath)
77 self.assertIsNone(settings.private_filepath)
78 self.assertIsNone(settings.delete_on_clean)
80 def test_name_priv_only(self):
81 settings = KeypairSettings(name='foo', private_filepath='/foo/bar')
82 self.assertEqual('foo', settings.name)
83 self.assertEqual(1024, settings.key_size)
84 self.assertIsNone(settings.public_filepath)
85 self.assertEqual('/foo/bar', settings.private_filepath)
86 self.assertIsNone(settings.delete_on_clean)
88 def test_config_with_name_priv_only(self):
89 settings = KeypairSettings(
90 **{'name': 'foo', 'private_filepath': '/foo/bar'})
91 self.assertEqual('foo', settings.name)
92 self.assertEqual(1024, settings.key_size)
93 self.assertIsNone(settings.public_filepath)
94 self.assertEqual('/foo/bar', settings.private_filepath)
95 self.assertIsNone(settings.delete_on_clean)
97 def test_all_delete_bool(self):
98 settings = KeypairSettings(
99 name='foo', public_filepath='/foo/bar.pub',
100 private_filepath='/foo/bar', delete_on_clean=True,
102 self.assertEqual('foo', settings.name)
103 self.assertEqual(999, settings.key_size)
104 self.assertEqual('/foo/bar.pub', settings.public_filepath)
105 self.assertEqual('/foo/bar', settings.private_filepath)
106 self.assertTrue(settings.delete_on_clean)
108 def test_all_delete_str_true_cap(self):
109 settings = KeypairSettings(
110 name='foo', public_filepath='/foo/bar.pub',
111 private_filepath='/foo/bar', delete_on_clean='True')
112 self.assertEqual('foo', settings.name)
113 self.assertEqual(1024, settings.key_size)
114 self.assertEqual('/foo/bar.pub', settings.public_filepath)
115 self.assertEqual('/foo/bar', settings.private_filepath)
116 self.assertTrue(settings.delete_on_clean)
118 def test_all_delete_str_true_lc(self):
119 settings = KeypairSettings(
120 name='foo', public_filepath='/foo/bar.pub',
121 private_filepath='/foo/bar', delete_on_clean='true')
122 self.assertEqual('foo', settings.name)
123 self.assertEqual(1024, settings.key_size)
124 self.assertEqual('/foo/bar.pub', settings.public_filepath)
125 self.assertEqual('/foo/bar', settings.private_filepath)
126 self.assertTrue(settings.delete_on_clean)
128 def test_all_delete_str_false_cap(self):
129 settings = KeypairSettings(
130 name='foo', public_filepath='/foo/bar.pub',
131 private_filepath='/foo/bar', delete_on_clean='False')
132 self.assertEqual('foo', settings.name)
133 self.assertEqual(1024, settings.key_size)
134 self.assertEqual('/foo/bar.pub', settings.public_filepath)
135 self.assertEqual('/foo/bar', settings.private_filepath)
136 self.assertFalse(settings.delete_on_clean)
138 def test_all_delete_str_false_lc(self):
139 settings = KeypairSettings(
140 name='foo', public_filepath='/foo/bar.pub',
141 private_filepath='/foo/bar', delete_on_clean='false',
143 self.assertEqual('foo', settings.name)
144 self.assertEqual(999, settings.key_size)
145 self.assertEqual('/foo/bar.pub', settings.public_filepath)
146 self.assertEqual('/foo/bar', settings.private_filepath)
147 self.assertFalse(settings.delete_on_clean)
149 def test_config_all_delete_false_bool(self):
150 settings = KeypairSettings(
151 **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
152 'private_filepath': '/foo/bar', 'delete_on_clean': False,
154 self.assertEqual('foo', settings.name)
155 self.assertEqual(999, settings.key_size)
156 self.assertEqual('/foo/bar.pub', settings.public_filepath)
157 self.assertEqual('/foo/bar', settings.private_filepath)
158 self.assertFalse(settings.delete_on_clean)
160 def test_config_all_delete_false_str_cap(self):
161 settings = KeypairSettings(
162 **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
163 'private_filepath': '/foo/bar', 'delete_on_clean': 'False'})
164 self.assertEqual('foo', settings.name)
165 self.assertEqual(1024, settings.key_size)
166 self.assertEqual('/foo/bar.pub', settings.public_filepath)
167 self.assertEqual('/foo/bar', settings.private_filepath)
168 self.assertFalse(settings.delete_on_clean)
170 def test_config_all_delete_false_str_lc(self):
171 settings = KeypairSettings(
172 **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
173 'private_filepath': '/foo/bar', 'delete_on_clean': 'false'})
174 self.assertEqual('foo', settings.name)
175 self.assertEqual(1024, settings.key_size)
176 self.assertEqual('/foo/bar.pub', settings.public_filepath)
177 self.assertEqual('/foo/bar', settings.private_filepath)
178 self.assertFalse(settings.delete_on_clean)
180 def test_config_all_delete_false_str_foo(self):
181 settings = KeypairSettings(
182 **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
183 'private_filepath': '/foo/bar', 'delete_on_clean': 'foo',
185 self.assertEqual('foo', settings.name)
186 self.assertEqual(999, settings.key_size)
187 self.assertEqual('/foo/bar.pub', settings.public_filepath)
188 self.assertEqual('/foo/bar', settings.private_filepath)
189 self.assertFalse(settings.delete_on_clean)
192 class CreateKeypairsTests(OSIntegrationTestCase):
194 Tests for the OpenStackKeypair class
198 super(self.__class__, self).__start__()
200 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
201 self.priv_file_path = 'tmp/' + guid
202 self.pub_file_path = self.priv_file_path + '.pub'
203 self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
204 self.keypair_name = guid
206 self.keypair_creator = None
210 Cleanup of created keypair
212 if self.keypair_creator:
213 self.keypair_creator.clean()
216 os.remove(self.pub_file_path)
221 os.remove(self.priv_file_path)
225 super(self.__class__, self).__clean__()
227 def test_create_keypair_only(self):
229 Tests the creation of a generated keypair without saving to file
232 self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairConfig(
233 name=self.keypair_name))
234 self.keypair_creator.create()
236 keypair = nova_utils.keypair_exists(self.nova,
237 self.keypair_creator.get_keypair())
238 self.assertEqual(self.keypair_creator.get_keypair(), keypair)
240 def test_create_keypair_large_key(self):
242 Tests the creation of a generated keypair without saving to file
245 self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairConfig(
246 name=self.keypair_name, key_size=10000))
247 self.keypair_creator.create()
249 keypair = nova_utils.keypair_exists(self.nova,
250 self.keypair_creator.get_keypair())
251 self.assertEqual(self.keypair_creator.get_keypair(), keypair)
253 def test_create_delete_keypair(self):
255 Tests the creation then deletion of an OpenStack keypair to ensure
256 clean() does not raise an Exception.
259 self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairConfig(
260 name=self.keypair_name))
261 created_keypair = self.keypair_creator.create()
262 self.assertIsNotNone(created_keypair)
264 # Delete Image manually
265 nova_utils.delete_keypair(self.nova, created_keypair)
268 nova_utils.get_keypair_by_name(self.nova, self.keypair_name))
270 # Must not throw an exception when attempting to cleanup non-existent
272 self.keypair_creator.clean()
273 self.assertIsNone(self.keypair_creator.get_keypair())
275 def test_create_keypair_save_pub_only(self):
277 Tests the creation of a generated keypair and saves the public key only
280 self.keypair_creator = OpenStackKeypair(
281 self.os_creds, KeypairConfig(
282 name=self.keypair_name, public_filepath=self.pub_file_path))
283 self.keypair_creator.create()
285 keypair = nova_utils.keypair_exists(self.nova,
286 self.keypair_creator.get_keypair())
287 self.assertEqual(self.keypair_creator.get_keypair(), keypair)
291 pub_file = open(os.path.expanduser(self.pub_file_path))
292 file_key = pub_file.read()
293 self.assertEqual(self.keypair_creator.get_keypair().public_key,
299 def test_create_keypair_save_both(self):
301 Tests the creation of a generated keypair and saves both private and
305 self.keypair_creator = OpenStackKeypair(
306 self.os_creds, KeypairConfig(
307 name=self.keypair_name, public_filepath=self.pub_file_path,
308 private_filepath=self.priv_file_path))
309 self.keypair_creator.create()
311 keypair = nova_utils.keypair_exists(self.nova,
312 self.keypair_creator.get_keypair())
313 self.assertEqual(self.keypair_creator.get_keypair(), keypair)
317 pub_file = open(os.path.expanduser(self.pub_file_path))
318 file_key = pub_file.read()
319 self.assertEqual(self.keypair_creator.get_keypair().public_key,
325 self.assertEqual(self.keypair_creator.get_keypair().public_key,
328 self.assertTrue(os.path.isfile(self.priv_file_path))
330 def test_create_keypair_from_file(self):
332 Tests the creation of an existing public keypair from a file
335 keys = nova_utils.create_keys()
336 file_utils.save_keys_to_files(keys=keys,
337 pub_file_path=self.pub_file_path)
338 self.keypair_creator = OpenStackKeypair(
339 self.os_creds, KeypairConfig(
340 name=self.keypair_name, public_filepath=self.pub_file_path))
341 self.keypair_creator.create()
343 keypair = nova_utils.keypair_exists(self.nova,
344 self.keypair_creator.get_keypair())
345 self.assertEqual(self.keypair_creator.get_keypair(), keypair)
349 pub_file = open(os.path.expanduser(self.pub_file_path))
350 file_key = pub_file.read()
351 self.assertEqual(self.keypair_creator.get_keypair().public_key,
357 self.assertEqual(self.keypair_creator.get_keypair().public_key,
361 class CreateKeypairsCleanupTests(OSIntegrationTestCase):
363 Tests for the OpenStackKeypair#clean method to ensure key files are deleted
368 super(self.__class__, self).__start__()
370 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
371 self.priv_file_path = 'tmp/' + guid
372 self.pub_file_path = self.priv_file_path + '.pub'
373 self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
374 self.keypair_name = guid
376 self.keypair_creator = None
380 Cleanup of created keypair
382 if self.keypair_creator:
383 self.keypair_creator.clean()
386 os.remove(self.pub_file_path)
391 os.remove(self.priv_file_path)
395 super(self.__class__, self).__clean__()
397 def test_create_keypair_gen_files_delete_1(self):
399 Tests the creation of a generated keypair and ensures that the files
400 are deleted on clean()
403 self.keypair_creator = OpenStackKeypair(
404 self.os_creds, KeypairConfig(
405 name=self.keypair_name, public_filepath=self.pub_file_path,
406 private_filepath=self.priv_file_path))
407 self.keypair_creator.create()
408 self.keypair_creator.clean()
410 self.assertFalse(file_utils.file_exists(self.pub_file_path))
411 self.assertFalse(file_utils.file_exists(self.priv_file_path))
413 def test_create_keypair_gen_files_delete_2(self):
415 Tests the creation of a generated keypair and ensures that the files
416 are deleted on clean()
419 self.keypair_creator = OpenStackKeypair(
420 self.os_creds, KeypairConfig(
421 name=self.keypair_name, public_filepath=self.pub_file_path,
422 private_filepath=self.priv_file_path, delete_on_clean=True))
423 self.keypair_creator.create()
424 self.keypair_creator.clean()
426 self.assertFalse(file_utils.file_exists(self.pub_file_path))
427 self.assertFalse(file_utils.file_exists(self.priv_file_path))
429 def test_create_keypair_gen_files_keep(self):
431 Tests the creation of a generated keypair and ensures that the files
432 are not deleted on clean()
435 self.keypair_creator = OpenStackKeypair(
436 self.os_creds, KeypairConfig(
437 name=self.keypair_name, public_filepath=self.pub_file_path,
438 private_filepath=self.priv_file_path, delete_on_clean=False))
439 self.keypair_creator.create()
440 self.keypair_creator.clean()
442 self.assertTrue(file_utils.file_exists(self.pub_file_path))
443 self.assertTrue(file_utils.file_exists(self.priv_file_path))
445 def test_create_keypair_exist_files_keep(self):
447 Tests the creation of an existing public keypair and ensures the files
448 are not deleted on clean
451 keys = nova_utils.create_keys()
452 file_utils.save_keys_to_files(
453 keys=keys, pub_file_path=self.pub_file_path,
454 priv_file_path=self.priv_file_path)
455 self.keypair_creator = OpenStackKeypair(
456 self.os_creds, KeypairConfig(
457 name=self.keypair_name, public_filepath=self.pub_file_path,
458 private_filepath=self.priv_file_path, delete_on_clean=False))
459 self.keypair_creator.create()
460 self.keypair_creator.clean()
462 self.assertTrue(file_utils.file_exists(self.pub_file_path))
463 self.assertTrue(file_utils.file_exists(self.priv_file_path))
465 def test_create_keypair_exist_files_delete(self):
467 Tests the creation of an existing public keypair and ensures the files
471 keys = nova_utils.create_keys()
472 file_utils.save_keys_to_files(
473 keys=keys, pub_file_path=self.pub_file_path,
474 priv_file_path=self.priv_file_path)
475 self.keypair_creator = OpenStackKeypair(
476 self.os_creds, KeypairConfig(
477 name=self.keypair_name, public_filepath=self.pub_file_path,
478 private_filepath=self.priv_file_path, delete_on_clean=True))
479 self.keypair_creator.create()
480 self.keypair_creator.clean()
482 self.assertFalse(file_utils.file_exists(self.pub_file_path))
483 self.assertFalse(file_utils.file_exists(self.priv_file_path))