snaps/openstack/tests/create_keypairs_tests.py

   1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
   2 #                    and others.  All rights reserved.
   3 #
   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:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  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.
  15 import unittest
  16 import uuid
  17
  18 import os
  19
  20 from snaps import file_utils
  21 from snaps.openstack.create_keypairs import (
  22     KeypairSettings, OpenStackKeypair, KeypairSettingsError)
  23 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
  24 from snaps.openstack.utils import nova_utils
  25
  26 __author__ = 'spisarski'
  27
  28
  29 class KeypairSettingsUnitTests(unittest.TestCase):
  30     """
  31     Tests the construction of the KeypairSettings class
  32     """
  33
  34     def test_no_params(self):
  35         with self.assertRaises(KeypairSettingsError):
  36             KeypairSettings()
  37
  38     def test_empty_config(self):
  39         with self.assertRaises(KeypairSettingsError):
  40             KeypairSettings(**dict())
  41
  42     def test_small_key_size(self):
  43         with self.assertRaises(KeypairSettingsError):
  44             KeypairSettings(name='foo', key_size=511)
  45
  46     def test_name_only(self):
  47         settings = KeypairSettings(name='foo')
  48         self.assertEqual('foo', settings.name)
  49         self.assertEqual(1024, settings.key_size)
  50         self.assertIsNone(settings.public_filepath)
  51         self.assertIsNone(settings.private_filepath)
  52         self.assertIsNone(settings.delete_on_clean)
  53
  54     def test_config_with_name_only(self):
  55         settings = KeypairSettings(**{'name': 'foo'})
  56         self.assertEqual('foo', settings.name)
  57         self.assertEqual(1024, settings.key_size)
  58         self.assertIsNone(settings.public_filepath)
  59         self.assertIsNone(settings.private_filepath)
  60         self.assertIsNone(settings.delete_on_clean)
  61
  62     def test_name_pub_only(self):
  63         settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub')
  64         self.assertEqual('foo', settings.name)
  65         self.assertEqual(1024, settings.key_size)
  66         self.assertEqual('/foo/bar.pub', settings.public_filepath)
  67         self.assertIsNone(settings.private_filepath)
  68         self.assertIsNone(settings.delete_on_clean)
  69
  70     def test_config_with_name_pub_only(self):
  71         settings = KeypairSettings(
  72             **{'name': 'foo', 'public_filepath': '/foo/bar.pub'})
  73         self.assertEqual('foo', settings.name)
  74         self.assertEqual(1024, settings.key_size)
  75         self.assertEqual('/foo/bar.pub', settings.public_filepath)
  76         self.assertIsNone(settings.private_filepath)
  77         self.assertIsNone(settings.delete_on_clean)
  78
  79     def test_name_priv_only(self):
  80         settings = KeypairSettings(name='foo', private_filepath='/foo/bar')
  81         self.assertEqual('foo', settings.name)
  82         self.assertEqual(1024, settings.key_size)
  83         self.assertIsNone(settings.public_filepath)
  84         self.assertEqual('/foo/bar', settings.private_filepath)
  85         self.assertIsNone(settings.delete_on_clean)
  86
  87     def test_config_with_name_priv_only(self):
  88         settings = KeypairSettings(
  89             **{'name': 'foo', 'private_filepath': '/foo/bar'})
  90         self.assertEqual('foo', settings.name)
  91         self.assertEqual(1024, settings.key_size)
  92         self.assertIsNone(settings.public_filepath)
  93         self.assertEqual('/foo/bar', settings.private_filepath)
  94         self.assertIsNone(settings.delete_on_clean)
  95
  96     def test_all_delete_bool(self):
  97         settings = KeypairSettings(
  98             name='foo', public_filepath='/foo/bar.pub',
  99             private_filepath='/foo/bar', delete_on_clean=True,
 100             key_size=999)
 101         self.assertEqual('foo', settings.name)
 102         self.assertEqual(999, settings.key_size)
 103         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 104         self.assertEqual('/foo/bar', settings.private_filepath)
 105         self.assertTrue(settings.delete_on_clean)
 106
 107     def test_all_delete_str_true_cap(self):
 108         settings = KeypairSettings(
 109             name='foo', public_filepath='/foo/bar.pub',
 110             private_filepath='/foo/bar', delete_on_clean='True')
 111         self.assertEqual('foo', settings.name)
 112         self.assertEqual(1024, settings.key_size)
 113         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 114         self.assertEqual('/foo/bar', settings.private_filepath)
 115         self.assertTrue(settings.delete_on_clean)
 116
 117     def test_all_delete_str_true_lc(self):
 118         settings = KeypairSettings(
 119             name='foo', public_filepath='/foo/bar.pub',
 120             private_filepath='/foo/bar', delete_on_clean='true')
 121         self.assertEqual('foo', settings.name)
 122         self.assertEqual(1024, settings.key_size)
 123         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 124         self.assertEqual('/foo/bar', settings.private_filepath)
 125         self.assertTrue(settings.delete_on_clean)
 126
 127     def test_all_delete_str_false_cap(self):
 128         settings = KeypairSettings(
 129             name='foo', public_filepath='/foo/bar.pub',
 130             private_filepath='/foo/bar', delete_on_clean='False')
 131         self.assertEqual('foo', settings.name)
 132         self.assertEqual(1024, settings.key_size)
 133         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 134         self.assertEqual('/foo/bar', settings.private_filepath)
 135         self.assertFalse(settings.delete_on_clean)
 136
 137     def test_all_delete_str_false_lc(self):
 138         settings = KeypairSettings(
 139             name='foo', public_filepath='/foo/bar.pub',
 140             private_filepath='/foo/bar', delete_on_clean='false',
 141             key_size='999')
 142         self.assertEqual('foo', settings.name)
 143         self.assertEqual(999, settings.key_size)
 144         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 145         self.assertEqual('/foo/bar', settings.private_filepath)
 146         self.assertFalse(settings.delete_on_clean)
 147
 148     def test_config_all_delete_false_bool(self):
 149         settings = KeypairSettings(
 150             **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
 151                'private_filepath': '/foo/bar', 'delete_on_clean': False,
 152                'key_size': 999})
 153         self.assertEqual('foo', settings.name)
 154         self.assertEqual(999, settings.key_size)
 155         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 156         self.assertEqual('/foo/bar', settings.private_filepath)
 157         self.assertFalse(settings.delete_on_clean)
 158
 159     def test_config_all_delete_false_str_cap(self):
 160         settings = KeypairSettings(
 161             **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
 162                'private_filepath': '/foo/bar', 'delete_on_clean': 'False'})
 163         self.assertEqual('foo', settings.name)
 164         self.assertEqual(1024, settings.key_size)
 165         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 166         self.assertEqual('/foo/bar', settings.private_filepath)
 167         self.assertFalse(settings.delete_on_clean)
 168
 169     def test_config_all_delete_false_str_lc(self):
 170         settings = KeypairSettings(
 171             **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
 172                'private_filepath': '/foo/bar', 'delete_on_clean': 'false'})
 173         self.assertEqual('foo', settings.name)
 174         self.assertEqual(1024, settings.key_size)
 175         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 176         self.assertEqual('/foo/bar', settings.private_filepath)
 177         self.assertFalse(settings.delete_on_clean)
 178
 179     def test_config_all_delete_false_str_foo(self):
 180         settings = KeypairSettings(
 181             **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
 182                'private_filepath': '/foo/bar', 'delete_on_clean': 'foo',
 183                'key_size': '999'})
 184         self.assertEqual('foo', settings.name)
 185         self.assertEqual(999, settings.key_size)
 186         self.assertEqual('/foo/bar.pub', settings.public_filepath)
 187         self.assertEqual('/foo/bar', settings.private_filepath)
 188         self.assertFalse(settings.delete_on_clean)
 189
 190
 191 class CreateKeypairsTests(OSIntegrationTestCase):
 192     """
 193     Tests for the OpenStackKeypair class
 194     """
 195
 196     def setUp(self):
 197         super(self.__class__, self).__start__()
 198
 199         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 200         self.priv_file_path = 'tmp/' + guid
 201         self.pub_file_path = self.priv_file_path + '.pub'
 202         self.nova = nova_utils.nova_client(self.os_creds)
 203         self.keypair_name = guid
 204
 205         self.keypair_creator = None
 206
 207     def tearDown(self):
 208         """
 209         Cleanup of created keypair
 210         """
 211         if self.keypair_creator:
 212             self.keypair_creator.clean()
 213
 214         try:
 215             os.remove(self.pub_file_path)
 216         except:
 217             pass
 218
 219         try:
 220             os.remove(self.priv_file_path)
 221         except:
 222             pass
 223
 224         super(self.__class__, self).__clean__()
 225
 226     def test_create_keypair_only(self):
 227         """
 228         Tests the creation of a generated keypair without saving to file
 229         :return:
 230         """
 231         self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(
 232             name=self.keypair_name))
 233         self.keypair_creator.create()
 234
 235         keypair = nova_utils.keypair_exists(self.nova,
 236                                             self.keypair_creator.get_keypair())
 237         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 238
 239     def test_create_keypair_large_key(self):
 240         """
 241         Tests the creation of a generated keypair without saving to file
 242         :return:
 243         """
 244         self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(
 245             name=self.keypair_name, key_size=10000))
 246         self.keypair_creator.create()
 247
 248         keypair = nova_utils.keypair_exists(self.nova,
 249                                             self.keypair_creator.get_keypair())
 250         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 251
 252     def test_create_delete_keypair(self):
 253         """
 254         Tests the creation then deletion of an OpenStack keypair to ensure
 255         clean() does not raise an Exception.
 256         """
 257         # Create Image
 258         self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(
 259             name=self.keypair_name))
 260         created_keypair = self.keypair_creator.create()
 261         self.assertIsNotNone(created_keypair)
 262
 263         # Delete Image manually
 264         nova_utils.delete_keypair(self.nova, created_keypair)
 265
 266         self.assertIsNone(
 267             nova_utils.get_keypair_by_name(self.nova, self.keypair_name))
 268
 269         # Must not throw an exception when attempting to cleanup non-existent
 270         # image
 271         self.keypair_creator.clean()
 272         self.assertIsNone(self.keypair_creator.get_keypair())
 273
 274     def test_create_keypair_save_pub_only(self):
 275         """
 276         Tests the creation of a generated keypair and saves the public key only
 277         :return:
 278         """
 279         self.keypair_creator = OpenStackKeypair(
 280             self.os_creds, KeypairSettings(name=self.keypair_name,
 281                                            public_filepath=self.pub_file_path))
 282         self.keypair_creator.create()
 283
 284         keypair = nova_utils.keypair_exists(self.nova,
 285                                             self.keypair_creator.get_keypair())
 286         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 287
 288         file_key = open(os.path.expanduser(self.pub_file_path)).read()
 289         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 290                          file_key)
 291
 292     def test_create_keypair_save_both(self):
 293         """
 294         Tests the creation of a generated keypair and saves both private and
 295         public key files[
 296         :return:
 297         """
 298         self.keypair_creator = OpenStackKeypair(
 299             self.os_creds, KeypairSettings(
 300                 name=self.keypair_name, public_filepath=self.pub_file_path,
 301                 private_filepath=self.priv_file_path))
 302         self.keypair_creator.create()
 303
 304         keypair = nova_utils.keypair_exists(self.nova,
 305                                             self.keypair_creator.get_keypair())
 306         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 307
 308         file_key = open(os.path.expanduser(self.pub_file_path)).read()
 309         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 310                          file_key)
 311
 312         self.assertTrue(os.path.isfile(self.priv_file_path))
 313
 314     def test_create_keypair_from_file(self):
 315         """
 316         Tests the creation of an existing public keypair from a file
 317         :return:
 318         """
 319         keys = nova_utils.create_keys()
 320         nova_utils.save_keys_to_files(keys=keys,
 321                                       pub_file_path=self.pub_file_path)
 322         self.keypair_creator = OpenStackKeypair(
 323             self.os_creds, KeypairSettings(name=self.keypair_name,
 324                                            public_filepath=self.pub_file_path))
 325         self.keypair_creator.create()
 326
 327         keypair = nova_utils.keypair_exists(self.nova,
 328                                             self.keypair_creator.get_keypair())
 329         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 330
 331         file_key = open(os.path.expanduser(self.pub_file_path)).read()
 332         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 333                          file_key)
 334
 335
 336 class CreateKeypairsCleanupTests(OSIntegrationTestCase):
 337     """
 338     Tests for the OpenStackKeypair#clean method to ensure key files are deleted
 339     when required
 340     """
 341
 342     def setUp(self):
 343         super(self.__class__, self).__start__()
 344
 345         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 346         self.priv_file_path = 'tmp/' + guid
 347         self.pub_file_path = self.priv_file_path + '.pub'
 348         self.nova = nova_utils.nova_client(self.os_creds)
 349         self.keypair_name = guid
 350
 351         self.keypair_creator = None
 352
 353     def tearDown(self):
 354         """
 355         Cleanup of created keypair
 356         """
 357         if self.keypair_creator:
 358             self.keypair_creator.clean()
 359
 360         try:
 361             os.remove(self.pub_file_path)
 362         except:
 363             pass
 364
 365         try:
 366             os.remove(self.priv_file_path)
 367         except:
 368             pass
 369
 370         super(self.__class__, self).__clean__()
 371
 372     def test_create_keypair_gen_files_delete_1(self):
 373         """
 374         Tests the creation of a generated keypair and ensures that the files
 375         are deleted on clean()
 376         :return:
 377         """
 378         self.keypair_creator = OpenStackKeypair(
 379             self.os_creds, KeypairSettings(
 380                 name=self.keypair_name, public_filepath=self.pub_file_path,
 381                 private_filepath=self.priv_file_path))
 382         self.keypair_creator.create()
 383         self.keypair_creator.clean()
 384
 385         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 386         self.assertFalse(file_utils.file_exists(self.priv_file_path))
 387
 388     def test_create_keypair_gen_files_delete_2(self):
 389         """
 390         Tests the creation of a generated keypair and ensures that the files
 391         are deleted on clean()
 392         :return:
 393         """
 394         self.keypair_creator = OpenStackKeypair(
 395             self.os_creds, KeypairSettings(
 396                 name=self.keypair_name, public_filepath=self.pub_file_path,
 397                 private_filepath=self.priv_file_path, delete_on_clean=True))
 398         self.keypair_creator.create()
 399         self.keypair_creator.clean()
 400
 401         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 402         self.assertFalse(file_utils.file_exists(self.priv_file_path))
 403
 404     def test_create_keypair_gen_files_keep(self):
 405         """
 406         Tests the creation of a generated keypair and ensures that the files
 407         are not deleted on clean()
 408         :return:
 409         """
 410         self.keypair_creator = OpenStackKeypair(
 411             self.os_creds, KeypairSettings(
 412                 name=self.keypair_name, public_filepath=self.pub_file_path,
 413                 private_filepath=self.priv_file_path, delete_on_clean=False))
 414         self.keypair_creator.create()
 415         self.keypair_creator.clean()
 416
 417         self.assertTrue(file_utils.file_exists(self.pub_file_path))
 418         self.assertTrue(file_utils.file_exists(self.priv_file_path))
 419
 420     def test_create_keypair_exist_files_keep(self):
 421         """
 422         Tests the creation of an existing public keypair and ensures the files
 423         are not deleted on clean
 424         :return:
 425         """
 426         keys = nova_utils.create_keys()
 427         nova_utils.save_keys_to_files(
 428             keys=keys, pub_file_path=self.pub_file_path,
 429             priv_file_path=self.priv_file_path)
 430         self.keypair_creator = OpenStackKeypair(
 431             self.os_creds, KeypairSettings(
 432                 name=self.keypair_name, public_filepath=self.pub_file_path,
 433                 private_filepath=self.priv_file_path, delete_on_clean=False))
 434         self.keypair_creator.create()
 435         self.keypair_creator.clean()
 436
 437         self.assertTrue(file_utils.file_exists(self.pub_file_path))
 438         self.assertTrue(file_utils.file_exists(self.priv_file_path))
 439
 440     def test_create_keypair_exist_files_delete(self):
 441         """
 442         Tests the creation of an existing public keypair and ensures the files
 443         are deleted on clean
 444         :return:
 445         """
 446         keys = nova_utils.create_keys()
 447         nova_utils.save_keys_to_files(
 448             keys=keys, pub_file_path=self.pub_file_path,
 449             priv_file_path=self.priv_file_path)
 450         self.keypair_creator = OpenStackKeypair(
 451             self.os_creds, KeypairSettings(
 452                 name=self.keypair_name, public_filepath=self.pub_file_path,
 453                 private_filepath=self.priv_file_path, delete_on_clean=True))
 454         self.keypair_creator.create()
 455         self.keypair_creator.clean()
 456
 457         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 458         self.assertFalse(file_utils.file_exists(self.priv_file_path))