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 from snaps.openstack.create_keypairs import (
  20     KeypairSettings, OpenStackKeypair, KeypairSettingsError)
  21 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
  22 from snaps.openstack.utils import nova_utils
  23
  24 __author__ = 'spisarski'
  25
  26
  27 class KeypairSettingsUnitTests(unittest.TestCase):
  28     """
  29     Tests the construction of the KeypairSettings class
  30     """
  31
  32     def test_no_params(self):
  33         with self.assertRaises(KeypairSettingsError):
  34             KeypairSettings()
  35
  36     def test_empty_config(self):
  37         with self.assertRaises(KeypairSettingsError):
  38             KeypairSettings(**dict())
  39
  40     def test_name_only(self):
  41         settings = KeypairSettings(name='foo')
  42         self.assertEqual('foo', settings.name)
  43         self.assertIsNone(settings.public_filepath)
  44         self.assertIsNone(settings.private_filepath)
  45
  46     def test_config_with_name_only(self):
  47         settings = KeypairSettings(**{'name': 'foo'})
  48         self.assertEqual('foo', settings.name)
  49         self.assertIsNone(settings.public_filepath)
  50         self.assertIsNone(settings.private_filepath)
  51
  52     def test_name_pub_only(self):
  53         settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub')
  54         self.assertEqual('foo', settings.name)
  55         self.assertEqual('/foo/bar.pub', settings.public_filepath)
  56         self.assertIsNone(settings.private_filepath)
  57
  58     def test_config_with_name_pub_only(self):
  59         settings = KeypairSettings(
  60             **{'name': 'foo', 'public_filepath': '/foo/bar.pub'})
  61         self.assertEqual('foo', settings.name)
  62         self.assertEqual('/foo/bar.pub', settings.public_filepath)
  63         self.assertIsNone(settings.private_filepath)
  64
  65     def test_name_priv_only(self):
  66         settings = KeypairSettings(name='foo', private_filepath='/foo/bar')
  67         self.assertEqual('foo', settings.name)
  68         self.assertIsNone(settings.public_filepath)
  69         self.assertEqual('/foo/bar', settings.private_filepath)
  70
  71     def test_config_with_name_priv_only(self):
  72         settings = KeypairSettings(
  73             **{'name': 'foo', 'private_filepath': '/foo/bar'})
  74         self.assertEqual('foo', settings.name)
  75         self.assertIsNone(settings.public_filepath)
  76         self.assertEqual('/foo/bar', settings.private_filepath)
  77
  78     def test_all(self):
  79         settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub',
  80                                    private_filepath='/foo/bar')
  81         self.assertEqual('foo', settings.name)
  82         self.assertEqual('/foo/bar.pub', settings.public_filepath)
  83         self.assertEqual('/foo/bar', settings.private_filepath)
  84
  85     def test_config_all(self):
  86         settings = KeypairSettings(
  87             **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
  88                'private_filepath': '/foo/bar'})
  89         self.assertEqual('foo', settings.name)
  90         self.assertEqual('/foo/bar.pub', settings.public_filepath)
  91         self.assertEqual('/foo/bar', settings.private_filepath)
  92
  93
  94 class CreateKeypairsTests(OSIntegrationTestCase):
  95     """
  96     Tests for the OpenStackKeypair class
  97     """
  98
  99     def setUp(self):
 100         super(self.__class__, self).__start__()
 101
 102         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 103         self.priv_file_path = 'tmp/' + guid
 104         self.pub_file_path = self.priv_file_path + '.pub'
 105         self.nova = nova_utils.nova_client(self.os_creds)
 106         self.keypair_name = guid
 107
 108         self.keypair_creator = None
 109
 110     def tearDown(self):
 111         """
 112         Cleanup of created keypair
 113         """
 114         if self.keypair_creator:
 115             self.keypair_creator.clean()
 116
 117         try:
 118             os.remove(self.pub_file_path)
 119         except:
 120             pass
 121
 122         try:
 123             os.remove(self.priv_file_path)
 124         except:
 125             pass
 126
 127         super(self.__class__, self).__clean__()
 128
 129     def test_create_keypair_only(self):
 130         """
 131         Tests the creation of a generated keypair without saving to file
 132         :return:
 133         """
 134         self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(
 135             name=self.keypair_name))
 136         self.keypair_creator.create()
 137
 138         keypair = nova_utils.keypair_exists(self.nova,
 139                                             self.keypair_creator.get_keypair())
 140         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 141
 142     def test_create_delete_keypair(self):
 143         """
 144         Tests the creation then deletion of an OpenStack keypair to ensure
 145         clean() does not raise an Exception.
 146         """
 147         # Create Image
 148         self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(
 149             name=self.keypair_name))
 150         created_keypair = self.keypair_creator.create()
 151         self.assertIsNotNone(created_keypair)
 152
 153         # Delete Image manually
 154         nova_utils.delete_keypair(self.nova, created_keypair)
 155
 156         self.assertIsNone(
 157             nova_utils.get_keypair_by_name(self.nova, self.keypair_name))
 158
 159         # Must not throw an exception when attempting to cleanup non-existent
 160         # image
 161         self.keypair_creator.clean()
 162         self.assertIsNone(self.keypair_creator.get_keypair())
 163
 164     def test_create_keypair_save_pub_only(self):
 165         """
 166         Tests the creation of a generated keypair and saves the public key only
 167         :return:
 168         """
 169         self.keypair_creator = OpenStackKeypair(
 170             self.os_creds, KeypairSettings(name=self.keypair_name,
 171                                            public_filepath=self.pub_file_path))
 172         self.keypair_creator.create()
 173
 174         keypair = nova_utils.keypair_exists(self.nova,
 175                                             self.keypair_creator.get_keypair())
 176         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 177
 178         file_key = open(os.path.expanduser(self.pub_file_path)).read()
 179         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 180                          file_key)
 181
 182     def test_create_keypair_save_both(self):
 183         """
 184         Tests the creation of a generated keypair and saves both private and
 185         public key files[
 186         :return:
 187         """
 188         self.keypair_creator = OpenStackKeypair(
 189             self.os_creds, KeypairSettings(
 190                 name=self.keypair_name, public_filepath=self.pub_file_path,
 191                 private_filepath=self.priv_file_path))
 192         self.keypair_creator.create()
 193
 194         keypair = nova_utils.keypair_exists(self.nova,
 195                                             self.keypair_creator.get_keypair())
 196         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 197
 198         file_key = open(os.path.expanduser(self.pub_file_path)).read()
 199         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 200                          file_key)
 201
 202         self.assertTrue(os.path.isfile(self.priv_file_path))
 203
 204     def test_create_keypair_from_file(self):
 205         """
 206         Tests the creation of an existing public keypair from a file
 207         :return:
 208         """
 209         keys = nova_utils.create_keys()
 210         nova_utils.save_keys_to_files(keys=keys,
 211                                       pub_file_path=self.pub_file_path)
 212         self.keypair_creator = OpenStackKeypair(
 213             self.os_creds, KeypairSettings(name=self.keypair_name,
 214                                            public_filepath=self.pub_file_path))
 215         self.keypair_creator.create()
 216
 217         keypair = nova_utils.keypair_exists(self.nova,
 218                                             self.keypair_creator.get_keypair())
 219         self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 220
 221         file_key = open(os.path.expanduser(self.pub_file_path)).read()
 222         self.assertEqual(self.keypair_creator.get_keypair().public_key,
 223                          file_key)