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         pub_file = None
 289         try:
 290             pub_file = open(os.path.expanduser(self.pub_file_path))
 291             file_key = pub_file.read()
 292             self.assertEqual(self.keypair_creator.get_keypair().public_key,
 293                              file_key)
 294         finally:
 295             if pub_file:
 296                 pub_file.close()
 297
 298     def test_create_keypair_save_both(self):
 299         """
 300         Tests the creation of a generated keypair and saves both private and
 301         public key files[
 302         :return:
 303         """
 304         self.keypair_creator = OpenStackKeypair(
 305             self.os_creds, KeypairSettings(
 306                 name=self.keypair_name, public_filepath=self.pub_file_path,
 307                 private_filepath=self.priv_file_path))
 308         self.keypair_creator.create()
 309
 310         keypair = nova_utils.keypair_exists(self.nova,
 311                                             self.keypair_creator.get_keypair())
 312         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 313
 314         pub_file = None
 315         try:
 316             pub_file = open(os.path.expanduser(self.pub_file_path))
 317             file_key = pub_file.read()
 318             self.assertEqual(self.keypair_creator.get_keypair().public_key,
 319                              file_key)
 320         finally:
 321             if pub_file:
 322                 pub_file.close()
 323
 324         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 325                          file_key)
 326
 327         self.assertTrue(os.path.isfile(self.priv_file_path))
 328
 329     def test_create_keypair_from_file(self):
 330         """
 331         Tests the creation of an existing public keypair from a file
 332         :return:
 333         """
 334         keys = nova_utils.create_keys()
 335         file_utils.save_keys_to_files(keys=keys,
 336                                       pub_file_path=self.pub_file_path)
 337         self.keypair_creator = OpenStackKeypair(
 338             self.os_creds, KeypairSettings(name=self.keypair_name,
 339                                            public_filepath=self.pub_file_path))
 340         self.keypair_creator.create()
 341
 342         keypair = nova_utils.keypair_exists(self.nova,
 343                                             self.keypair_creator.get_keypair())
 344         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 345
 346         pub_file = None
 347         try:
 348             pub_file = open(os.path.expanduser(self.pub_file_path))
 349             file_key = pub_file.read()
 350             self.assertEqual(self.keypair_creator.get_keypair().public_key,
 351                              file_key)
 352         finally:
 353             if pub_file:
 354                 pub_file.close()
 355
 356         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 357                          file_key)
 358
 359
 360 class CreateKeypairsCleanupTests(OSIntegrationTestCase):
 361     """
 362     Tests for the OpenStackKeypair#clean method to ensure key files are deleted
 363     when required
 364     """
 365
 366     def setUp(self):
 367         super(self.__class__, self).__start__()
 368
 369         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 370         self.priv_file_path = 'tmp/' + guid
 371         self.pub_file_path = self.priv_file_path + '.pub'
 372         self.nova = nova_utils.nova_client(self.os_creds)
 373         self.keypair_name = guid
 374
 375         self.keypair_creator = None
 376
 377     def tearDown(self):
 378         """
 379         Cleanup of created keypair
 380         """
 381         if self.keypair_creator:
 382             self.keypair_creator.clean()
 383
 384         try:
 385             os.remove(self.pub_file_path)
 386         except:
 387             pass
 388
 389         try:
 390             os.remove(self.priv_file_path)
 391         except:
 392             pass
 393
 394         super(self.__class__, self).__clean__()
 395
 396     def test_create_keypair_gen_files_delete_1(self):
 397         """
 398         Tests the creation of a generated keypair and ensures that the files
 399         are deleted on clean()
 400         :return:
 401         """
 402         self.keypair_creator = OpenStackKeypair(
 403             self.os_creds, KeypairSettings(
 404                 name=self.keypair_name, public_filepath=self.pub_file_path,
 405                 private_filepath=self.priv_file_path))
 406         self.keypair_creator.create()
 407         self.keypair_creator.clean()
 408
 409         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 410         self.assertFalse(file_utils.file_exists(self.priv_file_path))
 411
 412     def test_create_keypair_gen_files_delete_2(self):
 413         """
 414         Tests the creation of a generated keypair and ensures that the files
 415         are deleted on clean()
 416         :return:
 417         """
 418         self.keypair_creator = OpenStackKeypair(
 419             self.os_creds, KeypairSettings(
 420                 name=self.keypair_name, public_filepath=self.pub_file_path,
 421                 private_filepath=self.priv_file_path, delete_on_clean=True))
 422         self.keypair_creator.create()
 423         self.keypair_creator.clean()
 424
 425         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 426         self.assertFalse(file_utils.file_exists(self.priv_file_path))
 427
 428     def test_create_keypair_gen_files_keep(self):
 429         """
 430         Tests the creation of a generated keypair and ensures that the files
 431         are not deleted on clean()
 432         :return:
 433         """
 434         self.keypair_creator = OpenStackKeypair(
 435             self.os_creds, KeypairSettings(
 436                 name=self.keypair_name, public_filepath=self.pub_file_path,
 437                 private_filepath=self.priv_file_path, delete_on_clean=False))
 438         self.keypair_creator.create()
 439         self.keypair_creator.clean()
 440
 441         self.assertTrue(file_utils.file_exists(self.pub_file_path))
 442         self.assertTrue(file_utils.file_exists(self.priv_file_path))
 443
 444     def test_create_keypair_exist_files_keep(self):
 445         """
 446         Tests the creation of an existing public keypair and ensures the files
 447         are not deleted on clean
 448         :return:
 449         """
 450         keys = nova_utils.create_keys()
 451         file_utils.save_keys_to_files(
 452             keys=keys, pub_file_path=self.pub_file_path,
 453             priv_file_path=self.priv_file_path)
 454         self.keypair_creator = OpenStackKeypair(
 455             self.os_creds, KeypairSettings(
 456                 name=self.keypair_name, public_filepath=self.pub_file_path,
 457                 private_filepath=self.priv_file_path, delete_on_clean=False))
 458         self.keypair_creator.create()
 459         self.keypair_creator.clean()
 460
 461         self.assertTrue(file_utils.file_exists(self.pub_file_path))
 462         self.assertTrue(file_utils.file_exists(self.priv_file_path))
 463
 464     def test_create_keypair_exist_files_delete(self):
 465         """
 466         Tests the creation of an existing public keypair and ensures the files
 467         are deleted on clean
 468         :return:
 469         """
 470         keys = nova_utils.create_keys()
 471         file_utils.save_keys_to_files(
 472             keys=keys, pub_file_path=self.pub_file_path,
 473             priv_file_path=self.priv_file_path)
 474         self.keypair_creator = OpenStackKeypair(
 475             self.os_creds, KeypairSettings(
 476                 name=self.keypair_name, public_filepath=self.pub_file_path,
 477                 private_filepath=self.priv_file_path, delete_on_clean=True))
 478         self.keypair_creator.create()
 479         self.keypair_creator.clean()
 480
 481         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 482         self.assertFalse(file_utils.file_exists(self.priv_file_path))