| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, 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. |
| """ P1 tests for Project |
| """ |
| #Import Local Modules |
| import marvin |
| from nose.plugins.attrib import attr |
| from marvin.cloudstackTestCase import * |
| from marvin.cloudstackAPI import * |
| from marvin.lib.utils import * |
| from marvin.lib.base import * |
| from marvin.lib.common import * |
| from marvin.sshClient import SshClient |
| import datetime |
| |
| class TestUserProjectCreation(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.testClient = super(TestUserProjectCreation, cls).getClsTestClient() |
| cls.api_client = cls.testClient.getApiClient() |
| |
| cls.testdata = cls.testClient.getParsedTestDataConfig() |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) |
| cls.testdata['mode'] = cls.zone.networktype |
| |
| configs = Configurations.list( |
| cls.api_client, |
| name='allow.user.create.projects' |
| ) |
| |
| if not isinstance(configs, list): |
| raise unittest.SkipTest("List configurations has no config: allow.user.create.projects") |
| elif (configs[0].value).lower() != 'true': |
| raise unittest.SkipTest("'allow.user.create.projects' should be true") |
| |
| # Create domains, account etc. |
| cls.domain = Domain.create( |
| cls.api_client, |
| cls.testdata["domain"] |
| ) |
| |
| cls.account = Account.create( |
| cls.api_client, |
| cls.testdata["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls.user = Account.create( |
| cls.api_client, |
| cls.testdata["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls._cleanup = [cls.account, cls.user, cls.domain] |
| return |
| |
| @classmethod |
| def tearDownClass(cls): |
| try: |
| #Cleanup resources used |
| cleanup_resources(cls.api_client, cls._cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def setUp(self): |
| self.apiclient = self.testClient.getApiClient() |
| self.dbclient = self.testClient.getDbConnection() |
| self.cleanup = [] |
| return |
| |
| def tearDown(self): |
| try: |
| #Clean up, terminate the created accounts, domains etc |
| cleanup_resources(self.apiclient, self.cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| @attr(configuration = "allow.user.create.projects") |
| @attr(tags=["advanced", "basic", "sg", "eip", "advancedns", "simulator"], required_hardware="false") |
| def test_admin_project_creation(self): |
| """Test create project as a domain admin and domain user |
| """ |
| # Validate the following |
| # 1. Check if 'allow.user.create.projects' configuration is true |
| # 2. Create a Project as domain admin |
| # 3. Create a Project as domain user |
| # 4. In both 2 and 3 project creation should be successful |
| |
| configs = Configurations.list( |
| self.apiclient, |
| name='allow.user.create.projects' |
| ) |
| self.assertEqual( |
| isinstance(configs, list), |
| True, |
| "Check for a valid list configurations response" |
| ) |
| config = configs[0] |
| self.assertEqual( |
| (config.value).lower(), |
| 'true', |
| "'allow.user.create.projects' should be true" |
| ) |
| |
| # Create project as a domain admin |
| |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| self.debug("Created project with domain user with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| return |
| |
| |
| class TestProjectCreationNegative(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.testClient = super(TestProjectCreationNegative, cls).getClsTestClient() |
| cls.api_client = cls.testClient.getApiClient() |
| |
| cls.testdata = cls.testClient.getParsedTestDataConfig() |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) |
| cls.testdata['mode'] = cls.zone.networktype |
| |
| # Checking for prereqisits - global configs |
| configs = Configurations.list( |
| cls.api_client, |
| name='allow.user.create.projects' |
| ) |
| |
| if not isinstance(configs, list): |
| raise unittest.SkipTest("List configurations has no config: allow.user.create.projects") |
| elif (configs[0].value).lower() != 'false': |
| raise unittest.SkipTest("'allow.user.create.projects' should be false") |
| |
| # Create domains, account etc. |
| cls.domain = Domain.create( |
| cls.api_client, |
| cls.testdata["domain"] |
| ) |
| |
| cls.account = Account.create( |
| cls.api_client, |
| cls.testdata["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls.user = Account.create( |
| cls.api_client, |
| cls.testdata["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls._cleanup = [cls.account, cls.user, cls.domain] |
| return |
| |
| @classmethod |
| def tearDownClass(cls): |
| try: |
| #Cleanup resources used |
| cleanup_resources(cls.api_client, cls._cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def setUp(self): |
| self.apiclient = self.testClient.getApiClient() |
| self.dbclient = self.testClient.getDbConnection() |
| self.cleanup = [] |
| return |
| |
| def tearDown(self): |
| try: |
| #Clean up, terminate the created accounts, domains etc |
| cleanup_resources(self.apiclient, self.cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| @attr(configuration = "allow.user.create.projects") |
| @attr(tags = ["advanced", "basic", "sg", "eip", "advancedns", "simulator"]) |
| def test_user_project_creation(self): |
| """Test create project as a domain admin and domain user |
| """ |
| # Validate the following |
| # 1. Check if 'allow.user.create.projects' configuration is false |
| # 2. Create a Project as domain admin. Project creation should be |
| # successful. |
| # 3. Create a Project as domain user. Project creation should fail |
| |
| configs = Configurations.list( |
| self.apiclient, |
| name='allow.user.create.projects' |
| ) |
| self.assertEqual( |
| isinstance(configs, list), |
| True, |
| "Check for a valid list configurations response" |
| ) |
| config = configs[0] |
| self.assertEqual( |
| (config.value).lower(), |
| 'false', |
| "'allow.user.create.projects' should be true" |
| ) |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| with self.assertRaises(Exception): |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| self.debug("Project creation with domain user: %s failed" % |
| self.user.name) |
| return |
| |
| |
| class TestProjectInviteRequired(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.testClient = super(TestProjectInviteRequired, cls).getClsTestClient() |
| cls.api_client = cls.testClient.getApiClient() |
| |
| cls.testdata = cls.testClient.getParsedTestDataConfig() |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) |
| cls.testdata['mode'] = cls.zone.networktype |
| |
| # Create domains, account etc. |
| cls.domain = get_domain(cls.api_client) |
| |
| # Verify 'project.invite.required' is set to false |
| configs = Configurations.list( |
| cls.api_client, |
| name='project.invite.required' |
| ) |
| |
| if not isinstance(configs, list): |
| raise unittest.SkipTest("The 'project.invite.required' is not found in global configs") |
| elif (configs[0].value).lower() != 'false': |
| raise unittest.SkipTest("'project.invite.required' should be false") |
| |
| cls.account = Account.create( |
| cls.api_client, |
| cls.testdata["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls.user = Account.create( |
| cls.api_client, |
| cls.testdata["user"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls._cleanup = [cls.account, cls.user] |
| return |
| |
| @classmethod |
| def tearDownClass(cls): |
| try: |
| #Cleanup resources used |
| cleanup_resources(cls.api_client, cls._cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def setUp(self): |
| self.apiclient = self.testClient.getApiClient() |
| self.dbclient = self.testClient.getDbConnection() |
| self.cleanup = [] |
| return |
| |
| def tearDown(self): |
| try: |
| #Clean up, terminate the created accounts, domains etc |
| cleanup_resources(self.apiclient, self.cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| @attr(tags=["advanced", "basic", "sg", "eip", "advancedns"], required_hardware="false") |
| def test_add_user_to_project(self): |
| """Add user to project when 'project.invite.required' is false""" |
| |
| |
| # Validate the following: |
| # 1. Create a Project |
| # 2. Add users to the project. Verify user is added to project |
| # as regular user |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| self.debug("Adding %s user to project: %s" % ( |
| self.user.name, |
| project.name |
| )) |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| self.user.name, |
| self.user.user[0].email |
| ) |
| |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = Project.listAccounts( |
| self.apiclient, |
| projectid=project.id, |
| account=self.user.name, |
| ) |
| self.debug(accounts_response) |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.role, |
| 'Regular', |
| "Newly added user is not added as a regular user" |
| ) |
| |
| return |
| |
| class TestProjectInviteRequiredTrue(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| |
| cls.testClient = super(TestProjectInviteRequiredTrue, cls).getClsTestClient() |
| cls.api_client = cls.testClient.getApiClient() |
| |
| cls.testdata = cls.testClient.getParsedTestDataConfig() |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) |
| cls.testdata['mode'] = cls.zone.networktype |
| |
| # Create domains, account etc. |
| cls.domain = get_domain(cls.api_client) |
| |
| # Verify 'project.invite.required' is set to true |
| configs = Configurations.list( |
| cls.api_client, |
| name='project.invite.required' |
| ) |
| |
| if not isinstance(configs, list): |
| raise unittest.SkipTest("The 'project.invite.required' is not found in global configs") |
| elif (configs[0].value).lower() != 'true': |
| raise unittest.SkipTest("'project.invite.required' should be true") |
| |
| cls.account = Account.create( |
| cls.api_client, |
| cls.testdata["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls.user = Account.create( |
| cls.api_client, |
| cls.testdata["user"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls._cleanup = [cls.account, cls.user] |
| return |
| |
| @classmethod |
| def tearDownClass(cls): |
| try: |
| #Cleanup resources used |
| cleanup_resources(cls.api_client, cls._cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def setUp(self): |
| self.apiclient = self.testClient.getApiClient() |
| self.dbclient = self.testClient.getDbConnection() |
| self.cleanup = [] |
| return |
| |
| def tearDown(self): |
| try: |
| #Clean up, terminate the created accounts, domains etc |
| cleanup_resources(self.apiclient, self.cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| @attr(configuration = "project.invite.required") |
| @attr(tags=["advanced", "basic", "sg", "eip", "advancedns"], required_hardware="false") |
| def test_add_user_to_project(self): |
| """Add user to project when 'project.invite.required' is true""" |
| |
| |
| # Validate the following: |
| # 1. Create a Project |
| # 2. Add users to the project. verify user is shown in pending state |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| self.debug("Adding %s user to project: %s" % ( |
| self.user.name, |
| project.name |
| )) |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| self.user.name, |
| self.user.user[0].email |
| ) |
| |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = ProjectInvitation.list( |
| self.apiclient, |
| state='Pending', |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.state, |
| 'Pending', |
| "Newly added user is not added as a regular user" |
| ) |
| return |
| |
| |
| class TestProjectInviteTimeout(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.testClient = super(TestProjectInviteTimeout, cls).getClsTestClient() |
| cls.api_client = cls.testClient.getApiClient() |
| |
| cls.testdata = cls.testClient.getParsedTestDataConfig() |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) |
| cls.testdata['mode'] = cls.zone.networktype |
| |
| # Create domains, account etc. |
| cls.domain = get_domain(cls.api_client) |
| |
| # Verify 'project.invite.required' is set to true |
| configs = Configurations.list( |
| cls.api_client, |
| name='project.invite.required' |
| ) |
| |
| if not isinstance(configs, list): |
| raise unittest.SkipTest("The 'project.invite.required' is not found in global configs") |
| elif (configs[0].value).lower() != 'true': |
| raise unittest.SkipTest("'project.invite.required' should be true") |
| |
| # Verify 'project.invite.timeout' is set to 300 |
| configs = Configurations.list( |
| cls.api_client, |
| name='project.invite.timeout' |
| ) |
| |
| if not isinstance(configs, list): |
| raise unittest.SkipTest("The 'project.invite.timeout' is not found in global configs") |
| elif int(configs[0].value) != cls.testdata["configs"]["project.invite.timeout"]: |
| raise unittest.SkipTest("'project.invite.timeout' should be: %s " % |
| cls.testdata["configs"]["project.invite.timeout"]) |
| |
| cls.config = configs[0] |
| cls.account = Account.create( |
| cls.api_client, |
| cls.testdata["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls.user = Account.create( |
| cls.api_client, |
| cls.testdata["user"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls._cleanup = [cls.account, cls.user] |
| return |
| |
| @classmethod |
| def tearDownClass(cls): |
| try: |
| #Cleanup resources used |
| cleanup_resources(cls.api_client, cls._cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def setUp(self): |
| self.apiclient = self.testClient.getApiClient() |
| self.dbclient = self.testClient.getDbConnection() |
| self.cleanup = [] |
| return |
| |
| def tearDown(self): |
| try: |
| #Clean up, terminate the created accounts, domains etc |
| cleanup_resources(self.apiclient, self.cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| @attr(configuration = "project.invite.timeout") |
| @attr(tags = ["advanced", "basic", "sg", "eip", "advancedns", "simulator"]) |
| def test_01_invitation_timeout(self): |
| """Test global config project invitation timeout""" |
| |
| |
| # Validate the following: |
| # 1. Set configuration to 5 mins |
| # 2. Create a Project |
| # 3. Add users to the project |
| # 4. As a user accept invitation within 5 mins. Verify invitation is |
| # accepted and user become regular user of project |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| self.debug("Adding %s user to project: %s" % ( |
| self.user.name, |
| project.name |
| )) |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| self.user.name, |
| self.user.user[0].email |
| ) |
| |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = ProjectInvitation.list( |
| self.apiclient, |
| state='Pending', |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.state, |
| 'Pending', |
| "Newly added user is not added as a regular user" |
| ) |
| |
| # Accept the invite |
| ProjectInvitation.update( |
| self.apiclient, |
| projectid=project.id, |
| accept=True, |
| account=self.user.name |
| ) |
| self.debug( |
| "Accepting project invitation for project: %s user: %s" % ( |
| project.name, |
| self.user.name |
| )) |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = Project.listAccounts( |
| self.apiclient, |
| projectid=project.id, |
| account=self.user.name, |
| ) |
| |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.role, |
| 'Regular', |
| "Newly added user is not added as a regular user" |
| ) |
| return |
| |
| @attr(configuration = "project.invite.timeout") |
| @attr(tags = ["advanced", "basic", "sg", "eip", "advancedns", "simulator"]) |
| def test_02_invitation_timeout_after_expiry(self): |
| """Test global config project invitation timeout""" |
| |
| |
| # Validate the following: |
| # 1. Set configuration to 5 mins |
| # 2. Create a Project |
| # 3. Add users to the project |
| # 4. As a user accept invitation after 5 mins. Verify invitation is |
| # not accepted and is shown as expired |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| self.debug("Adding %s user to project: %s" % ( |
| self.user.name, |
| project.name |
| )) |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| self.user.name, |
| self.user.email |
| ) |
| |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = ProjectInvitation.list( |
| self.apiclient, |
| state='Pending', |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.state, |
| 'Pending', |
| "Newly added user is not added as a regular user" |
| ) |
| |
| # sleep for 'project.invite.timeout' * 2 interval to wait for invite |
| # to expire |
| time.sleep(int(self.config.value) * 2) |
| |
| with self.assertRaises(Exception): |
| # Accept the invite |
| ProjectInvitation.update( |
| self.apiclient, |
| projectid=project.id, |
| accept=True, |
| account=self.user.name |
| ) |
| self.debug( |
| "Accepting invitation after expiry project: %s user: %s" % ( |
| project.name, |
| self.user.name |
| )) |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = ProjectInvitation.list( |
| self.apiclient, |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.state, |
| 'Expired', |
| "Newly added user is not added as a regular user" |
| ) |
| return |
| |
| @attr(configuration = "project.invite.timeout") |
| @attr(tags = ["advanced", "basic", "sg", "eip", "advancedns", "simulator"]) |
| def test_03_invite_after_expiry(self): |
| """Test global config project invitation timeout""" |
| |
| # Validate the following: |
| # 1. Set configuration to 5 mins |
| # 2. Create a Project |
| # 3. Add users to the project |
| # 4. As a user accept invitation after 5 mins. |
| # 5. Resend the invitation |
| # 6. Verify invitation is sent again |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| self.debug("Adding %s user to project: %s" % ( |
| self.user.name, |
| project.name |
| )) |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| self.user.name, |
| self.user.email |
| ) |
| |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = ProjectInvitation.list( |
| self.apiclient, |
| state='Pending', |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.state, |
| 'Pending', |
| "Newly added user is not added as a regular user" |
| ) |
| |
| # sleep for 'project.invite.timeout' * 2 interval to wait for invite |
| # to expire |
| time.sleep(int(self.config.value) * 2) |
| |
| self.debug("Adding %s user again to project: %s" % ( |
| self.user.name, |
| project.name |
| )) |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| self.user.name, |
| self.user.email |
| ) |
| |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = ProjectInvitation.list( |
| self.apiclient, |
| state='Pending', |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.state, |
| 'Pending', |
| "Newly added user is not added as a regular user" |
| ) |
| return |
| |
| @attr(configuration = "project.invite.timeout") |
| @attr(tags = ["advanced", "basic", "sg", "eip", "advancedns", "simulator"]) |
| def test_04_decline_invitation(self): |
| """Test decline invitation""" |
| |
| # Validate the following: |
| # 1. Set configuration to 5 mins |
| # 2. Create a Project |
| # 3. Add users to the project |
| # 4. As a user decline invitation within 5 mins. |
| # 5. Verify invitation is rejected and user doesn't become regular |
| # user. |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| self.debug("Adding %s user to project: %s" % ( |
| self.user.name, |
| project.name |
| )) |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| self.user.name, |
| self.user.email |
| ) |
| |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = ProjectInvitation.list( |
| self.apiclient, |
| state='Pending', |
| account=self.user.name, |
| domainid=self.user.domainid |
| ) |
| self.assertEqual( |
| isinstance(accounts_response, list), |
| True, |
| "Check for a valid list accounts response" |
| ) |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| account = accounts_response[0] |
| |
| self.assertEqual( |
| account.state, |
| 'Pending', |
| "Newly added user is not added as a regular user" |
| ) |
| # Accept the invite |
| ProjectInvitation.update( |
| self.apiclient, |
| projectid=project.id, |
| accept=False, |
| account=self.user.name |
| ) |
| self.debug( |
| "Declining invitation for project: %s user: %s" % ( |
| project.name, |
| self.user.name |
| )) |
| # listProjectAccount to verify the user is added to project or not |
| accounts_response = Project.listAccounts( |
| self.apiclient, |
| projectid=project.id, |
| account=self.user.name, |
| ) |
| self.assertEqual( |
| accounts_response, |
| None, |
| "Check for a valid list accounts response" |
| ) |
| return |
| |
| def test_09_invite_to_project_by_email(self): |
| """Test invite user to project by email""" |
| |
| # Validate the following: |
| # 1. Set configuration to 5 mins |
| # 2. Create a Project |
| # 3. Add users to the project |
| # 4. As a user decline invitation within 5 mins. |
| # 5. Verify invitation is rejected and user doesn't become regular |
| # user. |
| |
| # Verify 'project.invite.required' is set to false |
| configs = Configurations.list( |
| self.apiclient, |
| name='project.invite.timeout' |
| ) |
| self.assertEqual( |
| isinstance(configs, list), |
| True, |
| "Check for a valid list configurations response" |
| ) |
| config = configs[0] |
| self.assertEqual( |
| int(config.value), |
| self.testdata["configs"]["project.invite.timeout"], |
| "'project.invite.timeout' should be %s" % |
| self.testdata["configs"]["project.invite.timeout"] |
| ) |
| |
| # Create project as a domain admin |
| project = Project.create( |
| self.apiclient, |
| self.testdata["project"], |
| account=self.account.name, |
| domainid=self.account.domainid |
| ) |
| # Cleanup created project at end of test |
| self.cleanup.append(project) |
| |
| self.debug("Created project with domain admin with ID: %s" % |
| project.id) |
| |
| list_projects_response = Project.list( |
| self.apiclient, |
| id=project.id, |
| listall=True |
| ) |
| |
| self.assertEqual( |
| isinstance(list_projects_response, list), |
| True, |
| "Check for a valid list projects response" |
| ) |
| list_project = list_projects_response[0] |
| |
| self.assertNotEqual( |
| len(list_projects_response), |
| 0, |
| "Check list project response returns a valid project" |
| ) |
| |
| self.assertEqual( |
| project.name, |
| list_project.name, |
| "Check project name from list response" |
| ) |
| self.debug("Adding user with email: %s to project: %s" % ( |
| self.user.email, |
| project.name |
| )) |
| |
| # Add user to the project |
| project.addAccount( |
| self.apiclient, |
| email=self.user.user[0].email |
| ) |
| |
| # Fetch the latest mail sent to user |
| mail_content = fetch_latest_mail( |
| self.testdata["mail_account"], |
| from_mail=self.user.user[0].email |
| ) |
| return |
