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.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
  26
  27 __author__ = 'spisarski'
  28
  29
  30 class KeypairSettingsUnitTests(unittest.TestCase):
  31     """
  32     Tests the construction of the KeypairSettings class
  33     """
  34
  35     def test_no_params(self):
  36         with self.assertRaises(KeypairConfigError):
  37             KeypairSettings()
  38
  39     def test_empty_config(self):
  40         with self.assertRaises(KeypairConfigError):
  41             KeypairSettings(**dict())
  42
  43     def test_small_key_size(self):
  44         with self.assertRaises(KeypairConfigError):
  45             KeypairSettings(name='foo', key_size=511)
  46
  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)
  54
  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)
  62
  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)
  70
  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)
  79
  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)
  87
  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)
  96
  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,
 101             key_size=999)
 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)
 107
 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)
 117
 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)
 127
 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)
 137
 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',
 142             key_size='999')
 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)
 148
 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,
 153                'key_size': 999})
 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)
 159
 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)
 169
 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)
 179
 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',
 184                'key_size': '999'})
 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)
 190
 191
 192 class CreateKeypairsTests(OSIntegrationTestCase):
 193     """
 194     Tests for the OpenStackKeypair class
 195     """
 196
 197     def setUp(self):
 198         super(self.__class__, self).__start__()
 199
 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)
 204         self.keypair_name = guid
 205
 206         self.keypair_creator = None
 207
 208     def tearDown(self):
 209         """
 210         Cleanup of created keypair
 211         """
 212         if self.keypair_creator:
 213             self.keypair_creator.clean()
 214
 215         try:
 216             os.remove(self.pub_file_path)
 217         except:
 218             pass
 219
 220         try:
 221             os.remove(self.priv_file_path)
 222         except:
 223             pass
 224
 225         super(self.__class__, self).__clean__()
 226
 227     def test_create_keypair_only(self):
 228         """
 229         Tests the creation of a generated keypair without saving to file
 230         :return:
 231         """
 232         self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairConfig(
 233             name=self.keypair_name))
 234         self.keypair_creator.create()
 235
 236         keypair = nova_utils.keypair_exists(self.nova,
 237                                             self.keypair_creator.get_keypair())
 238         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 239
 240     def test_create_keypair_large_key(self):
 241         """
 242         Tests the creation of a generated keypair without saving to file
 243         :return:
 244         """
 245         self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairConfig(
 246             name=self.keypair_name, key_size=10000))
 247         self.keypair_creator.create()
 248
 249         keypair = nova_utils.keypair_exists(self.nova,
 250                                             self.keypair_creator.get_keypair())
 251         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 252
 253     def test_create_delete_keypair(self):
 254         """
 255         Tests the creation then deletion of an OpenStack keypair to ensure
 256         clean() does not raise an Exception.
 257         """
 258         # Create Image
 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)
 263
 264         # Delete Image manually
 265         nova_utils.delete_keypair(self.nova, created_keypair)
 266
 267         self.assertIsNone(
 268             nova_utils.get_keypair_by_name(self.nova, self.keypair_name))
 269
 270         # Must not throw an exception when attempting to cleanup non-existent
 271         # image
 272         self.keypair_creator.clean()
 273         self.assertIsNone(self.keypair_creator.get_keypair())
 274
 275     def test_create_keypair_save_pub_only(self):
 276         """
 277         Tests the creation of a generated keypair and saves the public key only
 278         :return:
 279         """
 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()
 284
 285         keypair = nova_utils.keypair_exists(self.nova,
 286                                             self.keypair_creator.get_keypair())
 287         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 288
 289         pub_file = None
 290         try:
 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,
 294                              file_key)
 295         finally:
 296             if pub_file:
 297                 pub_file.close()
 298
 299     def test_create_keypair_save_both(self):
 300         """
 301         Tests the creation of a generated keypair and saves both private and
 302         public key files[
 303         :return:
 304         """
 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()
 310
 311         keypair = nova_utils.keypair_exists(self.nova,
 312                                             self.keypair_creator.get_keypair())
 313         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 314
 315         pub_file = None
 316         try:
 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,
 320                              file_key)
 321         finally:
 322             if pub_file:
 323                 pub_file.close()
 324
 325         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 326                          file_key)
 327
 328         self.assertTrue(os.path.isfile(self.priv_file_path))
 329
 330     def test_create_keypair_from_file(self):
 331         """
 332         Tests the creation of an existing public keypair from a file
 333         :return:
 334         """
 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()
 342
 343         keypair = nova_utils.keypair_exists(self.nova,
 344                                             self.keypair_creator.get_keypair())
 345         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 346
 347         pub_file = None
 348         try:
 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,
 352                              file_key)
 353         finally:
 354             if pub_file:
 355                 pub_file.close()
 356
 357         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 358                          file_key)
 359
 360
 361 class CreateKeypairsCleanupTests(OSIntegrationTestCase):
 362     """
 363     Tests for the OpenStackKeypair#clean method to ensure key files are deleted
 364     when required
 365     """
 366
 367     def setUp(self):
 368         super(self.__class__, self).__start__()
 369
 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)
 374         self.keypair_name = guid
 375
 376         self.keypair_creator = None
 377
 378     def tearDown(self):
 379         """
 380         Cleanup of created keypair
 381         """
 382         if self.keypair_creator:
 383             self.keypair_creator.clean()
 384
 385         try:
 386             os.remove(self.pub_file_path)
 387         except:
 388             pass
 389
 390         try:
 391             os.remove(self.priv_file_path)
 392         except:
 393             pass
 394
 395         super(self.__class__, self).__clean__()
 396
 397     def test_create_keypair_gen_files_delete_1(self):
 398         """
 399         Tests the creation of a generated keypair and ensures that the files
 400         are deleted on clean()
 401         :return:
 402         """
 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()
 409
 410         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 411         self.assertFalse(file_utils.file_exists(self.priv_file_path))
 412
 413     def test_create_keypair_gen_files_delete_2(self):
 414         """
 415         Tests the creation of a generated keypair and ensures that the files
 416         are deleted on clean()
 417         :return:
 418         """
 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()
 425
 426         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 427         self.assertFalse(file_utils.file_exists(self.priv_file_path))
 428
 429     def test_create_keypair_gen_files_keep(self):
 430         """
 431         Tests the creation of a generated keypair and ensures that the files
 432         are not deleted on clean()
 433         :return:
 434         """
 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()
 441
 442         self.assertTrue(file_utils.file_exists(self.pub_file_path))
 443         self.assertTrue(file_utils.file_exists(self.priv_file_path))
 444
 445     def test_create_keypair_exist_files_keep(self):
 446         """
 447         Tests the creation of an existing public keypair and ensures the files
 448         are not deleted on clean
 449         :return:
 450         """
 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()
 461
 462         self.assertTrue(file_utils.file_exists(self.pub_file_path))
 463         self.assertTrue(file_utils.file_exists(self.priv_file_path))
 464
 465     def test_create_keypair_exist_files_delete(self):
 466         """
 467         Tests the creation of an existing public keypair and ensures the files
 468         are deleted on clean
 469         :return:
 470         """
 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()
 481
 482         self.assertFalse(file_utils.file_exists(self.pub_file_path))
 483         self.assertFalse(file_utils.file_exists(self.priv_file_path))