Created domain object for flavors.

[snaps.git] / snaps / openstack / tests / create_keypairs_tests.py

diff --git a/snaps/openstack/tests/create_keypairs_tests.py b/snaps/openstack/tests/create_keypairs_tests.py
index e4409a9..29fe843 100644 (file)
--- a/snaps/openstack/tests/create_keypairs_tests.py
+++ b/snaps/openstack/tests/create_keypairs_tests.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2016 Cable Television Laboratories, Inc. ("CableLabs")
+# Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
 #                    and others.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,15 +12,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import os
-import uuid
 import unittest
+import uuid
 
-from Crypto.PublicKey import RSA
-
+import os
 from snaps.openstack.create_keypairs import KeypairSettings, OpenStackKeypair
-from snaps.openstack.utils import nova_utils
 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
+from snaps.openstack.utils import nova_utils
 
 __author__ = 'spisarski'
 
@@ -36,56 +34,60 @@ class KeypairSettingsUnitTests(unittest.TestCase):
 
     def test_empty_config(self):
         with self.assertRaises(Exception):
-            KeypairSettings(config=dict())
+            KeypairSettings(**dict())
 
     def test_name_only(self):
         settings = KeypairSettings(name='foo')
-        self.assertEquals('foo', settings.name)
+        self.assertEqual('foo', settings.name)
         self.assertIsNone(settings.public_filepath)
         self.assertIsNone(settings.private_filepath)
 
     def test_config_with_name_only(self):
-        settings = KeypairSettings(config={'name': 'foo'})
-        self.assertEquals('foo', settings.name)
+        settings = KeypairSettings(**{'name': 'foo'})
+        self.assertEqual('foo', settings.name)
         self.assertIsNone(settings.public_filepath)
         self.assertIsNone(settings.private_filepath)
 
     def test_name_pub_only(self):
         settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub')
-        self.assertEquals('foo', settings.name)
-        self.assertEquals('/foo/bar.pub', settings.public_filepath)
+        self.assertEqual('foo', settings.name)
+        self.assertEqual('/foo/bar.pub', settings.public_filepath)
         self.assertIsNone(settings.private_filepath)
 
     def test_config_with_name_pub_only(self):
-        settings = KeypairSettings(config={'name': 'foo', 'public_filepath': '/foo/bar.pub'})
-        self.assertEquals('foo', settings.name)
-        self.assertEquals('/foo/bar.pub', settings.public_filepath)
+        settings = KeypairSettings(
+            **{'name': 'foo', 'public_filepath': '/foo/bar.pub'})
+        self.assertEqual('foo', settings.name)
+        self.assertEqual('/foo/bar.pub', settings.public_filepath)
         self.assertIsNone(settings.private_filepath)
 
     def test_name_priv_only(self):
         settings = KeypairSettings(name='foo', private_filepath='/foo/bar')
-        self.assertEquals('foo', settings.name)
+        self.assertEqual('foo', settings.name)
         self.assertIsNone(settings.public_filepath)
-        self.assertEquals('/foo/bar', settings.private_filepath)
+        self.assertEqual('/foo/bar', settings.private_filepath)
 
     def test_config_with_name_priv_only(self):
-        settings = KeypairSettings(config={'name': 'foo', 'private_filepath': '/foo/bar'})
-        self.assertEquals('foo', settings.name)
+        settings = KeypairSettings(
+            **{'name': 'foo', 'private_filepath': '/foo/bar'})
+        self.assertEqual('foo', settings.name)
         self.assertIsNone(settings.public_filepath)
-        self.assertEquals('/foo/bar', settings.private_filepath)
+        self.assertEqual('/foo/bar', settings.private_filepath)
 
     def test_all(self):
-        settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub', private_filepath='/foo/bar')
-        self.assertEquals('foo', settings.name)
-        self.assertEquals('/foo/bar.pub', settings.public_filepath)
-        self.assertEquals('/foo/bar', settings.private_filepath)
+        settings = KeypairSettings(name='foo', public_filepath='/foo/bar.pub',
+                                   private_filepath='/foo/bar')
+        self.assertEqual('foo', settings.name)
+        self.assertEqual('/foo/bar.pub', settings.public_filepath)
+        self.assertEqual('/foo/bar', settings.private_filepath)
 
     def test_config_all(self):
-        settings = KeypairSettings(config={'name': 'foo', 'public_filepath': '/foo/bar.pub',
-                                           'private_filepath': '/foo/bar'})
-        self.assertEquals('foo', settings.name)
-        self.assertEquals('/foo/bar.pub', settings.public_filepath)
-        self.assertEquals('/foo/bar', settings.private_filepath)
+        settings = KeypairSettings(
+            **{'name': 'foo', 'public_filepath': '/foo/bar.pub',
+                    'private_filepath': '/foo/bar'})
+        self.assertEqual('foo', settings.name)
+        self.assertEqual('/foo/bar.pub', settings.public_filepath)
+        self.assertEqual('/foo/bar', settings.private_filepath)
 
 
 class CreateKeypairsTests(OSIntegrationTestCase):
@@ -128,27 +130,33 @@ class CreateKeypairsTests(OSIntegrationTestCase):
         Tests the creation of a generated keypair without saving to file
         :return:
         """
-        self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(name=self.keypair_name))
+        self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(
+            name=self.keypair_name))
         self.keypair_creator.create()
 
-        keypair = nova_utils.keypair_exists(self.nova, self.keypair_creator.get_keypair())
-        self.assertEquals(self.keypair_creator.get_keypair(), keypair)
+        keypair = nova_utils.keypair_exists(self.nova,
+                                            self.keypair_creator.get_keypair())
+        self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 
     def test_create_delete_keypair(self):
         """
-        Tests the creation then deletion of an OpenStack keypair to ensure clean() does not raise an Exception.
+        Tests the creation then deletion of an OpenStack keypair to ensure
+        clean() does not raise an Exception.
         """
         # Create Image
-        self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(name=self.keypair_name))
+        self.keypair_creator = OpenStackKeypair(self.os_creds, KeypairSettings(
+            name=self.keypair_name))
         created_keypair = self.keypair_creator.create()
         self.assertIsNotNone(created_keypair)
 
         # Delete Image manually
         nova_utils.delete_keypair(self.nova, created_keypair)
 
-        self.assertIsNone(nova_utils.get_keypair_by_name(self.nova, self.keypair_name))
+        self.assertIsNone(
+            nova_utils.get_keypair_by_name(self.nova, self.keypair_name))
 
-        # Must not throw an exception when attempting to cleanup non-existent image
+        # Must not throw an exception when attempting to cleanup non-existent
+        # image
         self.keypair_creator.clean()
         self.assertIsNone(self.keypair_creator.get_keypair())
 
@@ -158,30 +166,37 @@ class CreateKeypairsTests(OSIntegrationTestCase):
         :return:
         """
         self.keypair_creator = OpenStackKeypair(
-            self.os_creds, KeypairSettings(name=self.keypair_name, public_filepath=self.pub_file_path))
+            self.os_creds, KeypairSettings(name=self.keypair_name,
+                                           public_filepath=self.pub_file_path))
         self.keypair_creator.create()
 
-        keypair = nova_utils.keypair_exists(self.nova, self.keypair_creator.get_keypair())
-        self.assertEquals(self.keypair_creator.get_keypair(), keypair)
+        keypair = nova_utils.keypair_exists(self.nova,
+                                            self.keypair_creator.get_keypair())
+        self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 
         file_key = open(os.path.expanduser(self.pub_file_path)).read()
-        self.assertEquals(self.keypair_creator.get_keypair().public_key, file_key)
+        self.assertEqual(self.keypair_creator.get_keypair().public_key,
+                         file_key)
 
     def test_create_keypair_save_both(self):
         """
-        Tests the creation of a generated keypair and saves both private and public key files[
+        Tests the creation of a generated keypair and saves both private and
+        public key files[
         :return:
         """
         self.keypair_creator = OpenStackKeypair(
-            self.os_creds, KeypairSettings(name=self.keypair_name, public_filepath=self.pub_file_path,
-                                           private_filepath=self.priv_file_path))
+            self.os_creds, KeypairSettings(
+                name=self.keypair_name, public_filepath=self.pub_file_path,
+                private_filepath=self.priv_file_path))
         self.keypair_creator.create()
 
-        keypair = nova_utils.keypair_exists(self.nova, self.keypair_creator.get_keypair())
-        self.assertEquals(self.keypair_creator.get_keypair(), keypair)
+        keypair = nova_utils.keypair_exists(self.nova,
+                                            self.keypair_creator.get_keypair())
+        self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 
         file_key = open(os.path.expanduser(self.pub_file_path)).read()
-        self.assertEquals(self.keypair_creator.get_keypair().public_key, file_key)
+        self.assertEqual(self.keypair_creator.get_keypair().public_key,
+                         file_key)
 
         self.assertTrue(os.path.isfile(self.priv_file_path))
 
@@ -190,14 +205,18 @@ class CreateKeypairsTests(OSIntegrationTestCase):
         Tests the creation of an existing public keypair from a file
         :return:
         """
-        keys = RSA.generate(1024)
-        nova_utils.save_keys_to_files(keys=keys, pub_file_path=self.pub_file_path)
+        keys = nova_utils.create_keys()
+        nova_utils.save_keys_to_files(keys=keys,
+                                      pub_file_path=self.pub_file_path)
         self.keypair_creator = OpenStackKeypair(
-            self.os_creds, KeypairSettings(name=self.keypair_name, public_filepath=self.pub_file_path))
+            self.os_creds, KeypairSettings(name=self.keypair_name,
+                                           public_filepath=self.pub_file_path))
         self.keypair_creator.create()
 
-        keypair = nova_utils.keypair_exists(self.nova, self.keypair_creator.get_keypair())
-        self.assertEquals(self.keypair_creator.get_keypair(), keypair)
+        keypair = nova_utils.keypair_exists(self.nova,
+                                            self.keypair_creator.get_keypair())
+        self.assertEqual(self.keypair_creator.get_keypair(), keypair)
 
         file_key = open(os.path.expanduser(self.pub_file_path)).read()
-        self.assertEquals(self.keypair_creator.get_keypair().public_key, file_key)
+        self.assertEqual(self.keypair_creator.get_keypair().public_key,
+                         file_key)