snaps/openstack/tests/create_user_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 from snaps.openstack.create_user import OpenStackUser, UserSettings
  19 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
  20 from snaps.openstack.utils import keystone_utils
  21
  22 __author__ = 'spisarski'
  23
  24
  25 class UserSettingsUnitTests(unittest.TestCase):
  26     """
  27     Tests the construction of the UserSettings class
  28     """
  29
  30     def test_no_params(self):
  31         with self.assertRaises(Exception):
  32             UserSettings()
  33
  34     def test_empty_config(self):
  35         with self.assertRaises(Exception):
  36             UserSettings(**dict())
  37
  38     def test_name_only(self):
  39         with self.assertRaises(Exception):
  40             UserSettings(name='foo')
  41
  42     def test_config_with_name_only(self):
  43         with self.assertRaises(Exception):
  44             UserSettings(**{'name': 'foo'})
  45
  46     def test_name_pass_enabled_str(self):
  47         with self.assertRaises(Exception):
  48             UserSettings(name='foo', password='bar', enabled='true')
  49
  50     def test_config_with_name_pass_enabled_str(self):
  51         with self.assertRaises(Exception):
  52             UserSettings(
  53                 **{'name': 'foo', 'password': 'bar', 'enabled': 'true'})
  54
  55     def test_name_pass_only(self):
  56         settings = UserSettings(name='foo', password='bar')
  57         self.assertEqual('foo', settings.name)
  58         self.assertEqual('bar', settings.password)
  59         self.assertIsNone(settings.project_name)
  60         self.assertIsNone(settings.email)
  61         self.assertTrue(settings.enabled)
  62
  63     def test_config_with_name_pass_only(self):
  64         settings = UserSettings(**{'name': 'foo', 'password': 'bar'})
  65         self.assertEqual('foo', settings.name)
  66         self.assertEqual('bar', settings.password)
  67         self.assertIsNone(settings.project_name)
  68         self.assertIsNone(settings.email)
  69         self.assertTrue(settings.enabled)
  70
  71     def test_all(self):
  72         settings = UserSettings(name='foo', password='bar',
  73                                 project_name='proj-foo', email='foo@bar.com',
  74                                 enabled=False)
  75         self.assertEqual('foo', settings.name)
  76         self.assertEqual('bar', settings.password)
  77         self.assertEqual('proj-foo', settings.project_name)
  78         self.assertEqual('foo@bar.com', settings.email)
  79         self.assertFalse(settings.enabled)
  80
  81     def test_config_all(self):
  82         settings = UserSettings(**{'name': 'foo', 'password': 'bar',
  83                                    'project_name': 'proj-foo',
  84                                    'email': 'foo@bar.com',
  85                                    'enabled': False})
  86         self.assertEqual('foo', settings.name)
  87         self.assertEqual('bar', settings.password)
  88         self.assertEqual('proj-foo', settings.project_name)
  89         self.assertEqual('foo@bar.com', settings.email)
  90         self.assertFalse(settings.enabled)
  91
  92
  93 class CreateUserSuccessTests(OSComponentTestCase):
  94     """
  95     Test for the CreateImage class defined in create_image.py
  96     """
  97
  98     def setUp(self):
  99         """
 100         Instantiates the CreateImage object that is responsible for downloading
 101         and creating an OS image file within OpenStack
 102         """
 103         guid = str(uuid.uuid4())[:-19]
 104         guid = self.__class__.__name__ + '-' + guid
 105         self.user_settings = UserSettings(name=guid + '-name',
 106                                           password=guid + '-password')
 107
 108         self.keystone = keystone_utils.keystone_client(self.os_creds)
 109
 110         # Initialize for cleanup
 111         self.user_creator = None
 112
 113     def tearDown(self):
 114         """
 115         Cleans the image and downloaded image file
 116         """
 117         if self.user_creator:
 118             self.user_creator.clean()
 119
 120     def test_create_user(self):
 121         """
 122         Tests the creation of an OpenStack user.
 123         """
 124         self.user_creator = OpenStackUser(self.os_creds, self.user_settings)
 125         created_user = self.user_creator.create()
 126         self.assertIsNotNone(created_user)
 127
 128         retrieved_user = keystone_utils.get_user(self.keystone,
 129                                                  self.user_settings.name)
 130         self.assertIsNotNone(retrieved_user)
 131         self.assertEqual(created_user, retrieved_user)
 132
 133     def test_create_user_2x(self):
 134         """
 135         Tests the creation of an OpenStack user twice to ensure it only creates
 136         one.
 137         """
 138         self.user_creator = OpenStackUser(self.os_creds, self.user_settings)
 139         created_user = self.user_creator.create()
 140         self.assertIsNotNone(created_user)
 141
 142         retrieved_user = keystone_utils.get_user(self.keystone,
 143                                                  self.user_settings.name)
 144         self.assertIsNotNone(retrieved_user)
 145         self.assertEqual(created_user, retrieved_user)
 146
 147         # Create user for the second time to ensure it is the same
 148         user2 = OpenStackUser(self.os_creds, self.user_settings).create()
 149         self.assertEqual(retrieved_user, user2)
 150
 151     def test_create_delete_user(self):
 152         """
 153         Tests the creation of an OpenStack user then delete.
 154         """
 155         # Create Image
 156         self.user_creator = OpenStackUser(self.os_creds, self.user_settings)
 157         created_user = self.user_creator.create()
 158         self.assertIsNotNone(created_user)
 159
 160         keystone_utils.delete_user(self.keystone, created_user)
 161
 162         # Delete user
 163         self.user_creator.clean()
 164         self.assertIsNone(self.user_creator.get_user())