Add support to run tests in a user-specified single tenant

Currently each test suite creates its own projects/users
In production test environments, the admin would allocate
a specific project where the tests are expected to run
(stackUser, stackPassword and stackTenant in sanity_params.ini)

If tenant_isolation is enabled and admin credentials are
mentioned in sanity_params.ini, the existing behavior will
be seen

Corresponding fab code changes : https://review.opencontrail.org/16483

Change-Id: I13e5d0983472b1a8f9d2ecdd6f79e5df043ee04b

common/connections.py

@@ -98,16 +98,12 @@ def get_auth_h(self, refresh=False, project_name=None,
                                        project_name, self.inputs)
         return env[attr]
 
-    def get_vnc_lib_h(self, refresh=False, project_name=None,
-                      username=None, password=None):
-        project_name = project_name or self.project_name
-        username = username or self.username
-        password = password or self.password
-        attr = '_vnc_lib_'+project_name+'_'+username
+    def get_vnc_lib_h(self, refresh=False):
+        attr = '_vnc_lib_' + self.project_name + '_' + self.username
         if not getattr(env, attr, None) or refresh:
             self.vnc_lib_fixture = VncLibFixture(
-                username=username, password=password,
-                domain=self.domain_name, project_name=project_name,
+                username=self.username, password=self.password,
+                domain=self.domain_name, project_name=self.project_name,
                 inputs = self.inputs,
                 cfgm_ip=self.inputs.cfgm_ip,
                 api_server_port=self.inputs.api_server_port,

common/contrail_test_init.py

@@ -73,26 +73,47 @@ def __init__(self, ini_file=None):
                                             'Basic', 'provFile', None)
         self.key = read_config_option(self.config,
                                       'Basic', 'key', 'key1')
+
+        self.tenant_isolation = read_config_option(self.config,
+            'Basic',
+            'tenant_isolation',
+            True)
+        # Read admin credentials if any
+
+        self.admin_username = read_config_option(self.config,
+            'Basic',
+            'adminUser',
+            os.getenv('OS_USERNAME', None))
+        self.admin_password = read_config_option(self.config,
+            'Basic',
+            'adminPassword',
+            os.getenv('OS_PASSWORD', None))
+        self.admin_tenant = read_config_option(self.config,
+            'Basic',
+            'adminTenant',
+            os.getenv('OS_TENANT_NAME', None))
+
         self.stack_user = read_config_option(
             self.config,
             'Basic',
             'stackUser',
-            os.getenv('OS_USERNAME', 'admin'))
+            self.admin_username)
         self.stack_password = read_config_option(
             self.config,
             'Basic',
             'stackPassword',
-            os.getenv('OS_PASSWORD', 'contrail123'))
+            self.admin_password)
         self.stack_tenant = read_config_option(
             self.config,
             'Basic',
             'stackTenant',
-            os.getenv('OS_TENANT_NAME', 'admin'))
+            self.admin_tenant)
         self.stack_domain = read_config_option(
             self.config,
             'Basic',
             'stackDomain',
             os.getenv('OS_DOMAIN_NAME', 'default-domain'))
+
         self.endpoint_type = read_config_option(
             self.config,
             'Basic',

common/create_public_vn.py

@@ -15,36 +15,37 @@
 class PublicVn(fixtures.Fixture):
     __metaclass__ = Singleton
 
-    def __init__(self, user, password, inputs, ini_file = None ,logger = None, mx_rt = None):
+    def __init__(self, isolated_creds_obj, inputs, ini_file = None ,logger = None, mx_rt = None):
 
-#        self.project_name = project_name
-        self.user_name = user
-        self.password = password
+        self.isolated_creds = isolated_creds_obj
+        self.username = self.isolated_creds.username
+        self.password = self.isolated_creds.password
         self.inputs = inputs
         self.ini_file = ini_file
         self.logger = logger
         self.public_vn = self.inputs.public_vn 
-        self.public_tenant = self.inputs.public_tenant
+        self.public_tenant = self.inputs.admin_tenant
         self.setUp()
         self.create_public_vn(mx_rt)
         self.create_floatingip_pool()
         self.configure_control_nodes()
 
     def setUp(self):
         super(PublicVn, self).setUp()
-        self.isolated_creds = isolated_creds.IsolatedCreds(self.public_tenant, \
-                self.inputs, ini_file = self.ini_file, \
-                logger = self.logger,
-                username=self.user_name,
-                password=self.password)
-        self.isolated_creds.setUp()
-        self.project = self.isolated_creds.create_tenant()
-        self.isolated_creds.create_and_attach_user_to_tenant()
-        self.inputs = self.isolated_creds.get_inputs()
-        self.connections = self.isolated_creds.get_conections()
-        self.isolated_creds.create_and_attach_user_to_tenant(self.user_name,self.password)
-        self.project.set_sec_group_for_allow_all(\
-                 self.public_tenant, 'default')
+        self.project = self.isolated_creds.create_tenant(self.public_tenant)
+        self.inputs = self.isolated_creds.get_inputs(self.project)
+        self.connections = self.isolated_creds.get_connections(self.inputs)
+        if self.isolated_creds.__class__.__name__ == 'AdminIsolatedCreds':
+            # If AdminIsolatedCreds, one could add user to tenant
+            # Else, it is assumed that the administrator has taken 
+            # care 
+            self.isolated_creds.create_and_attach_user_to_tenant(
+                self.project,
+                self.username,
+                self.password)
+            self.project.set_sec_group_for_allow_all(\
+                     self.public_tenant, 'default')
+    # end setUp
 
     def create_public_vn(self,mx_rt = None):
         if (('MX_GW_TEST' in os.environ) and (

common/isolated_creds.py

@@ -7,128 +7,173 @@
 import time
 from tcutils.util import get_random_name
 
-ADMIN_TENANT = 'admin'
+
+
 
 class IsolatedCreds(fixtures.Fixture):
 
-    def __init__(self,project_name, inputs, ini_file=None, logger=None,
+    def __init__(self, inputs, project_name=None, ini_file=None, logger=None,
                  username=None, password=None):
 
+        self.username = None
+        self.password = None
         self.inputs = inputs
-        self.admin_tenant = self.inputs.stack_tenant
-        if (self.inputs.public_tenant == project_name):
-            self.project_name = project_name
-        else: 
-            self.project_name = get_random_name(project_name) 
-        if username:
-            self.user = username
-        else:
-            self.user = project_name
-        if password:
-            self.password = password
-        else:
+
+        if inputs.tenant_isolation:
+            self.project_name = get_random_name(project_name)
+            self.username = project_name
             self.password = project_name
+        else :
+            self.project_name = project_name or inputs.stack_tenant
+            self.username = username or inputs.stack_user
+            self.password = password or inputs.stack_password
+
         self.ini_file = ini_file
         self.logger = logger
         if self.inputs.orchestrator == 'vcenter':
             self.project_name = self.inputs.stack_tenant
-            self.user = self.inputs.stack_user
+            self.username = self.inputs.stack_user
             self.password = self.inputs.stack_password
+    # end __init__
 
     def setUp(self):
         super(IsolatedCreds, self).setUp()
-        self.connections= ContrailConnections(self.inputs, self.logger)
+        self.connections= ContrailConnections(self.inputs, self.logger,
+            username=self.username,
+            password=self.password,
+            project_name=self.project_name)
         self.vnc_lib= self.connections.vnc_lib
         self.auth = self.connections.auth
 
-    def create_tenant(self): 
+    def use_tenant(self, project_fixture):
+        self.project = project_fixture
 
-        self.project = None
-        time.sleep(4)        
+    def create_tenant(self, project_name):
+        ''' Get a Project. Returns instance of ProjectFixture
+            Creates the project if not found
+        ''' 
+        project = None
         try:
-            self.project = project_test.ProjectFixture(project_name = self.project_name, auth=self.auth,
-					vnc_lib_h= self.vnc_lib,username= self.user,password= self.password,
-                                        connections= self.connections)
-            self.project.setUp()
+            project = project_test.ProjectFixture(
+                project_name = project_name,
+                auth=self.auth,
+                vnc_lib_h= self.vnc_lib,
+                username= self.username,
+                password= self.password,
+                connections= self.connections)
+            project.setUp()
         except Exception as e:
-            self.logger.warn("got exception as %s"%(e)) 
+            self.logger.exception("Exception while creating project")
         finally:
-            return self.project
-
-    def delete_tenant(self):
+            return project
+    # end create_tenant
 
-        self.project.cleanUp()
+    def delete_tenant(self, project_fixture):
+        project_fixture.cleanUp()
 
-    def delete_user(self,user=None):
-        if self.inputs.orchestrator == 'vcenter':
-            return
-        if user:
-            user = user
-	else:
-	    user = self.user
-        self.auth.delete_user(user)
-
-    def create_and_attach_user_to_tenant(self,user = None , password=None):
-        if self.inputs.orchestrator == 'vcenter':
-            return
-        user = user if user else self.user
-        password = password if password else self.password
-        self.auth.create_user(user,password)
-        self.auth.add_user_to_project(user, self.project_name)
-        self.auth.add_user_to_project('admin', self.project_name)
-        time.sleep(4)
-
-    def get_inputs(self):
-
-        self.project_inputs= ContrailTestInit(self.ini_file,
-                            stack_user=self.project.username,
-                            stack_password=self.project.password,
+    def get_inputs(self, project_fixture):
+        project_inputs= ContrailTestInit(self.ini_file,
+                            stack_user=project_fixture.username,
+                            stack_password=project_fixture.password,
                             project_fq_name=['default-domain',self.project_name],logger = self.logger)
-        return self.project_inputs
-
-    def get_conections(self):
-        self.project_connections= ContrailConnections(self.project_inputs,
-                                    project_name= self.project_name,
-                                    username=self.project.username,
-                                    password= self.project.password,
-                                    logger = self.logger)
+        return project_inputs
+
+    def get_connections(self, project_inputs):
+        self.project_connections= ContrailConnections(project_inputs,
+                                    project_name=self.project_name,
+                                    username=self.username,
+                                    password=self.password,
+                                    logger=self.logger)
         return self.project_connections
 
-    def get_admin_inputs(self):
-
-        admin = AdminCreds(self.admin_tenant , self.inputs , self.ini_file , self.logger)
-        return admin.get_inputs()		
-
-    def get_admin_connections(self):
-
-        admin = AdminCreds(self.admin_tenant , self.inputs , self.ini_file , self.logger)
-        return admin.get_conections()	
-
     def cleanUp(self):
         super(IsolatedCreds, self).cleanUp()
 
-class AdminCreds(fixtures.Fixture):
-
-    def __init__(self,project_name,inputs,ini_file = None ,logger = None):
+# end IsolatedCreds
 
-        self.project_name = project_name
-        self.user = project_name 
-        self.password = project_name
+class AdminIsolatedCreds(fixtures.Fixture):
+    def __init__(self, inputs, admin_project_name=None, ini_file=None, logger=None,
+        username=None, password=None):
+        self.project_name = admin_project_name or inputs.admin_tenant
+        self.username = username or inputs.admin_username
+        self.password = password or inputs.admin_password
         self.inputs = inputs
+
         self.ini_file = ini_file
         self.logger = logger
+        if self.inputs.orchestrator == 'vcenter':
+            self.project_name = self.inputs.stack_tenant
+            self.username = self.inputs.stack_user
+            self.password = self.inputs.stack_password
 
-    def get_inputs(self):
-
-        return self.inputs
-
-    def get_conections(self): 
-
-        connections= ContrailConnections(self.inputs,project_name= self.project_name,
-				   username=self.inputs.stack_user
-                                  ,password= self.inputs.stack_password,
-                                   logger = self.logger)
-        return connections
-
-    def cleanUp(self):
-        super(AdminCreds, self).cleanUp()
+    # end __init__
+
+    def setUp(self):
+        self.connections = ContrailConnections(self.inputs, self.logger,
+            project_name=self.project_name,
+            username=self.username,
+            password=self.password)
+        self.vnc_lib = self.connections.vnc_lib
+        self.auth = self.connections.auth
+
+    def delete_user(self, user):
+        if self.inputs.orchestrator == 'vcenter':
+            return
+        self.auth.delete_user(user)
+    # end delete_user
+
+    def create_and_attach_user_to_tenant(self, project_fixture, 
+            username, password):
+        project_fixture.set_user_creds(username, password)
+        project_name = project_fixture.project_name
+        if self.inputs.orchestrator == 'vcenter':
+            return
+        if self.inputs.tenant_isolation:
+            self.auth.create_user(username, password)
+            self.auth.add_user_to_project(username, project_name)
+            if self.inputs.admin_username:
+                self.auth.add_user_to_project(self.inputs.admin_username, project_name)
+    # end create_and_attach_user_to_tenant
+
+    def use_tenant(self, project_fixture):
+        self.project = project_fixture
+
+    def create_tenant(self, project_name):
+        ''' Get a Project. Returns instance of ProjectFixture
+            Creates the project if not found
+        '''
+
+        project = None
+        try:
+            project = project_test.ProjectFixture(
+                project_name = project_name,
+                auth=self.auth,
+                vnc_lib_h= self.vnc_lib,
+                username= self.username,
+                password= self.password,
+                connections= self.connections)
+            project.setUp()
+        except Exception as e:
+            self.logger.exception("Exception while creating project")
+        finally:
+            return project
+    # end create_tenant
+
+    def delete_tenant(self, project_fixture):
+        project_fixture.cleanUp()
+
+    def get_inputs(self, project_fixture):
+        project_inputs= ContrailTestInit(self.ini_file,
+                            stack_user=project_fixture.username,
+                            stack_password=project_fixture.password,
+                            project_fq_name=['default-domain',self.project_name],logger = self.logger)
+        return project_inputs
+
+    def get_connections(self, project_inputs):
+        self.project_connections= ContrailConnections(project_inputs,
+                                    project_name=self.project_name,
+                                    username=self.username,
+                                    password=self.password,
+                                    logger=self.logger)
+        return self.project_connections
+# end AdminIsolatedCreds