Python OpenEdXInstanceFactory.provision方法代码示例

# 需要导入模块: from instance.tests.models.factories.instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.instance.OpenEdXInstanceFactory import provision [as 别名]
    def test_provision_no_active(self, os_server_manager, mock_deploy, mock_set_dns_record,
                                 mock_server_reboot, mock_sleep, mock_update_status):
        """
        Run provisioning sequence, with status jumping from 'started' to 'booted' (no 'active')
        """
        mock_deploy.return_value = (['log'], 0)
        instance = OpenEdXInstanceFactory(sub_domain='run.provisioning.noactive')
        status_queue = [
            OpenStackServer.STARTED,
            OpenStackServer.BOOTED,
            OpenStackServer.BOOTED,
            OpenStackServer.PROVISIONING,
            OpenStackServer.REBOOTING,
            OpenStackServer.READY,
        ]
        status_queue.reverse() # To be able to use pop()

        def update_status(self, provisioning=False, rebooting=False, failed=None):
            """ Simulate status progression successive runs """
            self.status = status_queue.pop()
            self.progress = self.PROGRESS_SUCCESS
        mock_update_status.side_effect = update_status

        with patch('instance.models.server.OpenStackServer.start'):
            instance.provision()
        self.assertEqual(mock_deploy.call_count, 1)

# 需要导入模块: from instance.tests.models.factories.instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.instance.OpenEdXInstanceFactory import provision [as 别名]
    def test_provision_with_external_databases(self, mocks):
        """
        Run provisioning sequence, with external databases
        """
        mocks.mock_create_server.side_effect = [Mock(id='test-run-provisioning-server'), None]
        mocks.os_server_manager.add_fixture('test-run-provisioning-server', 'openstack/api_server_2_active.json')

        instance = OpenEdXInstanceFactory(sub_domain='run.provisioning', use_ephemeral_databases=False)

        def deploy():
            """
            Make sure that ansible settings are present at deploy time
            """
            ansible_settings = yaml.load(instance.ansible_settings)
            for setting in ('EDXAPP_MYSQL_USER', 'EDXAPP_MONGO_PASSWORD',
                            'EDXAPP_MONGO_USER', 'EDXAPP_MONGO_PASSWORD',
                            'EDXAPP_SWIFT_USERNAME', 'EDXAPP_SWIFT_KEY'):
                self.assertTrue(ansible_settings[setting])
            return (['log'], 0)

        mocks.mock_deploy.side_effect = deploy
        instance.provision()
        self.assertEqual(mocks.mock_provision_mysql.call_count, 1)
        self.assertEqual(mocks.mock_provision_mongo.call_count, 1)
        self.assertEqual(mocks.mock_provision_swift.call_count, 1)

# 需要导入模块: from instance.tests.models.factories.instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.instance.OpenEdXInstanceFactory import provision [as 别名]
    def test_provision_unhandled_exception(self, mocks):
        """
        Make sure that all servers are terminated if there is an unhandled exception during
        provisioning.
        """
        mocks.mock_set_dns_record.side_effect = Exception('Something went catastrophically wrong')
        instance = OpenEdXInstanceFactory(sub_domain='run.provisioning')
        with self.assertRaisesRegex(Exception, 'Something went catastrophically wrong'):
            instance.provision()
        self.assertFalse(instance.server_set.exclude_terminated())

        mocks.mock_provision_failed_email.assert_called_once_with(instance.ProvisionMessages.PROVISION_EXCEPTION)

# 需要导入模块: from instance.tests.models.factories.instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.instance.OpenEdXInstanceFactory import provision [as 别名]
    def test_provision(self, os_server_manager, mock_run_playbook, mock_set_dns_record, mock_server_reboot,
                       mock_sleep_until_status, mock_update_status, mock_openstack_create_server):
        """
        Run provisioning sequence
        """
        mock_openstack_create_server.return_value.id = 'test-run-provisioning-server'
        os_server_manager.add_fixture('test-run-provisioning-server', 'openstack/api_server_2_active.json')

        instance = OpenEdXInstanceFactory(sub_domain='run.provisioning')
        instance.provision()
        self.assertEqual(mock_set_dns_record.mock_calls, [
            call(name='run.provisioning', type='A', value='192.168.100.200'),
            call(name='studio.run.provisioning', type='CNAME', value='run.provisioning'),
        ])
        self.assertEqual(mock_run_playbook.call_count, 1)
        self.assertEqual(mock_server_reboot.call_count, 1)

# 需要导入模块: from instance.tests.models.factories.instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.instance.OpenEdXInstanceFactory import provision [as 别名]
    def test_provision(self, mocks):
        """
        Run provisioning sequence
        """
        mocks.mock_deploy.return_value = (['log'], 0)
        mocks.mock_create_server.side_effect = [Mock(id='test-run-provisioning-server'), None]
        mocks.os_server_manager.add_fixture('test-run-provisioning-server', 'openstack/api_server_2_active.json')
        mock_reboot = mocks.os_server_manager.get_os_server('test-run-provisioning-server').reboot

        instance = OpenEdXInstanceFactory(sub_domain='run.provisioning', use_ephemeral_databases=True)
        instance.provision()
        self.assertEqual(mocks.mock_set_dns_record.mock_calls, [
            call(name='run.provisioning', type='A', value='192.168.100.200'),
            call(name='studio.run.provisioning', type='CNAME', value='run.provisioning'),
        ])
        self.assertEqual(mocks.mock_deploy.call_count, 1)
        self.assertEqual(mock_reboot.call_count, 1)
        self.assertEqual(mocks.mock_provision_mysql.call_count, 0)
        self.assertEqual(mocks.mock_provision_mongo.call_count, 0)
        self.assertEqual(mocks.mock_provision_swift.call_count, 0)

# 需要导入模块: from instance.tests.models.factories.instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.instance.OpenEdXInstanceFactory import provision [as 别名]
    def test_provision_failed(self, mocks):
        """
        Run provisioning sequence failing the deployment on purpose to make sure the
        server status will be set accordingly.
        """
        log_lines = ['log']
        mocks.mock_deploy.return_value = (log_lines, 1)
        instance = OpenEdXInstanceFactory(sub_domain='run.provisioning')

        server = instance.provision()[0]
        self.assertEqual(server.status, Server.Status.Provisioning)
        self.assertEqual(server.progress, Server.Progress.Failed)
        mocks.mock_provision_failed_email.assert_called_once_with(instance.ProvisionMessages.PROVISION_ERROR, log_lines)
        mocks.mock_provision_failed_email.assert_called_once_with(instance.ProvisionMessages.PROVISION_ERROR, log_lines)

# 需要导入模块: from instance.tests.models.factories.instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.instance.OpenEdXInstanceFactory import provision [as 别名]
    def test_provision_failed(self, os_server_manager, mock_deploy, mock_set_dns_record,
                              mock_server_start, mock_os_server, mock_sleep_until_status):
        """
        Run provisioning sequence failing the deployment on purpose to make sure the
        server status will be set accordingly.
        """
        mock_deploy.return_value = (['log'], 1)
        instance = OpenEdXInstanceFactory(sub_domain='run.provisioning')

        def server_start(self):
            """
            Make sure we get the server in the BOOTED state when it is started
            """
            self.status = Server.BOOTED
            self.progress = Server.PROGRESS_SUCCESS
        mock_server_start.side_effect = server_start

        server = instance.provision()[0]
        self.assertEqual(server.status, Server.PROVISIONING)
        self.assertEqual(server.progress, Server.PROGRESS_FAILED)