def test_provision_failed_email(self): """ Tests that provision_failed sends email when called from normal program flow """ instance = OpenEdXInstanceFactory(name='test', sub_domain='test') reason = "something went wrong" log_lines = ["log line1", "log_line2"] instance.provision_failed_email(reason, log_lines) expected_subject = OpenEdXInstance.EmailSubject.PROVISION_FAILED.format( instance_name=instance.name, instance_url=instance.url) expected_recipients = [ admin_tuple[1] for admin_tuple in settings.ADMINS ] self.assertEqual(len(django_mail.outbox), 1) mail = django_mail.outbox[0] self.assertIn(expected_subject, mail.subject) self.assertIn(instance.name, mail.body) self.assertIn(reason, mail.body) self.assertEqual(mail.from_email, settings.SERVER_EMAIL) self.assertEqual(mail.to, expected_recipients) self.assertEqual(len(mail.attachments), 1) self.assertEqual(mail.attachments[0], ("provision.log", "\n".join(log_lines), "text/plain"))
def test_provision_mongo(self): """ Provision mongo databases """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_mongo() self.check_mongo(instance)
def test_ansible_s3_settings(self): """ Add extra settings in ansible vars, which can override existing settings """ instance = OpenEdXInstanceFactory( s3_access_key='test-s3-access-key', s3_secret_access_key='test-s3-secret-access-key', s3_bucket_name='test-s3-bucket-name', ) instance.reset_ansible_settings() self.assertIn('AWS_ACCESS_KEY_ID: test-s3-access-key', instance.ansible_settings) self.assertIn('AWS_SECRET_ACCESS_KEY: test-s3-secret-access-key', instance.ansible_settings) self.assertIn( 'EDXAPP_AUTH_EXTRA: {AWS_STORAGE_BUCKET_NAME: test-s3-bucket-name}', instance.ansible_settings) self.assertIn('EDXAPP_AWS_ACCESS_KEY_ID: test-s3-access-key', instance.ansible_settings) self.assertIn( 'EDXAPP_AWS_SECRET_ACCESS_KEY: test-s3-secret-access-key', instance.ansible_settings) self.assertIn('XQUEUE_AWS_ACCESS_KEY_ID: test-s3-access-key', instance.ansible_settings) self.assertIn( 'XQUEUE_AWS_SECRET_ACCESS_KEY: test-s3-secret-access-key', instance.ansible_settings) self.assertIn('XQUEUE_S3_BUCKET: test-s3-bucket-name', instance.ansible_settings)
def test_ansible_settings_mysql_not_set(self): """ Don't add mysql ansible vars if INSTANCE_MYSQL_URL is not set """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.reset_ansible_settings() self.check_mysql_vars_not_set(instance)
def test_ansible_settings_mysql_ephemeral(self): """ Don't add mysql ansible vars for ephemeral databases """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=True) instance.reset_ansible_settings() self.check_mysql_vars_not_set(instance)
def test_provision_mysql(self): """ Provision mysql database """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_mysql() self.check_mysql(instance)
def test_provision_failed_email(self): """ Tests that provision_failed sends email when called from normal program flow """ instance = OpenEdXInstanceFactory(name='test', sub_domain='test') reason = "something went wrong" log_lines = ["log line1", "log_line2"] instance.provision_failed_email(reason, log_lines) expected_subject = OpenEdXInstance.EmailSubject.PROVISION_FAILED.format( instance_name=instance.name, instance_url=instance.url ) expected_recipients = [admin_tuple[1] for admin_tuple in settings.ADMINS] self.assertEqual(len(django_mail.outbox), 1) mail = django_mail.outbox[0] self.assertIn(expected_subject, mail.subject) self.assertIn(instance.name, mail.body) self.assertIn(reason, mail.body) self.assertEqual(mail.from_email, settings.SERVER_EMAIL) self.assertEqual(mail.to, expected_recipients) self.assertEqual(len(mail.attachments), 1) self.assertEqual(mail.attachments[0], ("provision.log", "\n".join(log_lines), "text/plain"))
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)
def test_ansible_settings_mongo(self): """ Add mongo ansible vars if INSTANCE_MONGO_URL is set """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.reset_ansible_settings() self.assertIn('EDXAPP_MONGO_USER: {0}'.format(instance.mongo_user), instance.ansible_settings) self.assertIn('EDXAPP_MONGO_PASSWORD: {0}'.format(instance.mongo_pass), instance.ansible_settings) self.assertIn('EDXAPP_MONGO_HOSTS: [mongo.opencraft.com]', instance.ansible_settings) self.assertIn('EDXAPP_MONGO_PORT: 27017', instance.ansible_settings) self.assertIn( 'EDXAPP_MONGO_DB_NAME: {0}'.format(instance.mongo_database_name), instance.ansible_settings) self.assertIn('FORUM_MONGO_USER: {0}'.format(instance.mongo_user), instance.ansible_settings) self.assertIn('FORUM_MONGO_PASSWORD: {0}'.format(instance.mongo_pass), instance.ansible_settings) self.assertIn('FORUM_MONGO_HOSTS: [mongo.opencraft.com]', instance.ansible_settings) self.assertIn('FORUM_MONGO_PORT: 27017', instance.ansible_settings) self.assertIn( 'FORUM_MONGO_DATABASE: {0}'.format(instance.forum_database_name), instance.ansible_settings)
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)
def test_ansible_settings_mongo_ephemeral(self): """ Don't add mongo ansible vars if INSTANCE_MONGO_URL is not set """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=True) instance.reset_ansible_settings() self.check_mongo_vars_not_set(instance)
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)
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)
def test_provision_failed_exception_email(self): """ Tests that provision_failed sends email when called from exception handler """ instance = OpenEdXInstanceFactory(name='exception_test', sub_domain='exception_test') reason = "something went wrong" log_lines = ["log line1", "log_line2"] exception_message = "Something Bad happened Unexpectedly" exception = Exception(exception_message) try: raise exception except Exception: # pylint: disable=broad-except instance.provision_failed_email(reason, log_lines) expected_subject = OpenEdXInstance.EmailSubject.PROVISION_FAILED.format( instance_name=instance.name, instance_url=instance.url ) expected_recipients = [admin_tuple[1] for admin_tuple in settings.ADMINS] self.assertEqual(len(django_mail.outbox), 1) mail = django_mail.outbox[0] self.assertIn(expected_subject, mail.subject) self.assertIn(instance.name, mail.body) self.assertIn(reason, mail.body) self.assertEqual(mail.from_email, settings.SERVER_EMAIL) self.assertEqual(mail.to, expected_recipients) self.assertEqual(len(mail.attachments), 2) self.assertEqual(mail.attachments[0], ("provision.log", "\n".join(log_lines), "text/plain")) name, content, mime_type = mail.attachments[1] self.assertEqual(name, "debug.html") self.assertIn(exception_message, content) self.assertEqual(mime_type, "text/html")
def test_reset_ansible_settings(self): """ Ansible vars as a string """ instance = OpenEdXInstanceFactory( name='Vars Instance', sub_domain='vars.test', email='*****@*****.**', github_organization_name='vars-org', github_repository_name='vars-repo', commit_id='9' * 40, ansible_source_repo_url='http://example.org/config/repo', configuration_version='test-config-ver', forum_version='test-forum-ver', notifier_version='test-notif-ver', xqueue_version='test-xq-ver', certs_version='test-cert-ver', ) instance.reset_ansible_settings() self.assertIn('EDXAPP_PLATFORM_NAME: "Vars Instance"', instance.ansible_settings) self.assertIn("EDXAPP_SITE_NAME: 'vars.test.example.com", instance.ansible_settings) self.assertIn("EDXAPP_CMS_SITE_NAME: 'studio.vars.test.example.com'", instance.ansible_settings) self.assertIn("EDXAPP_CONTACT_EMAIL: '*****@*****.**'", instance.ansible_settings) self.assertIn("edx_platform_repo: 'https://github.com/vars-org/vars-repo.git'", instance.ansible_settings) self.assertIn("edx_platform_version: '{}'".format('9' * 40), instance.ansible_settings) self.assertIn("edx_ansible_source_repo: 'http://example.org/config/repo'", instance.ansible_settings) self.assertIn("configuration_version: 'test-config-ver'", instance.ansible_settings) self.assertIn("forum_version: 'test-forum-ver'", instance.ansible_settings) self.assertIn("notifier_version: 'test-notif-ver'", instance.ansible_settings) self.assertIn("xqueue_version: 'test-xq-ver'", instance.ansible_settings) self.assertIn("certs_version: 'test-cert-ver'", instance.ansible_settings)
def test_swift_disabled(self, mock_swift_connection): """ Verify disabling Swift provisioning works. """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_swift() self.assertIs(instance.swift_provisioned, False) self.assertFalse(mock_swift_connection.called)
def test_commit_short_id(self): """ Short representation of a commit_id """ instance = OpenEdXInstanceFactory(commit_id='6e580ca9fed6fb65ec45949494dabec40e8cb533') self.assertEqual(instance.commit_short_id, '6e580ca') instance.commit_id = None self.assertEqual(instance.commit_short_id, None)
def test_set_to_branch_tip_replace_commit_hash(self, mock_get_commit_id_from_ref): """ The hash should be updated in the instance name when updating """ mock_get_commit_id_from_ref.return_value = '1234567' + 'd' * 33 instance = OpenEdXInstanceFactory(commit_id='a' * 40, name='Test Instance (aaaaaaa)') instance.set_to_branch_tip(branch_name='new-branch', ref_type='tag') self.assertEqual(instance.name, 'Test Instance (1234567)')
def test_github_admin_username_list_default(self): """ By default, no admin should be configured """ instance = OpenEdXInstanceFactory() instance.reset_ansible_settings() self.assertEqual(instance.github_admin_organization_name, '') self.assertEqual(instance.github_admin_username_list, []) self.assertNotIn('COMMON_USER_INFO', instance.ansible_settings)
def test_commit_short_id(self): """ Short representation of a commit_id """ instance = OpenEdXInstanceFactory( commit_id='6e580ca9fed6fb65ec45949494dabec40e8cb533') self.assertEqual(instance.commit_short_id, '6e580ca') instance.commit_id = None self.assertEqual(instance.commit_short_id, None)
def test_provision_mysql_no_url(self): """ Don't provision a mysql database if INSTANCE_MYSQL_URL is not set """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_mysql() databases = subprocess.check_output("mysql -u root -e 'SHOW DATABASES'", shell=True).decode() for database in instance.mysql_database_names: self.assertNotIn(database, databases)
def test_set_to_branch_tip_extra_args(self, mock_get_commit_id_from_ref): """ Set the commit id to the tip of a specified reference """ mock_get_commit_id_from_ref.return_value = 'c' * 40 instance = OpenEdXInstanceFactory(commit_id='a' * 40) instance.set_to_branch_tip(branch_name='new-branch', ref_type='tag') self.assertEqual(instance.commit_id, 'c' * 40) self.assertEqual(instance.branch_name, 'new-branch') self.assertEqual(instance.ref_type, 'tag')
def test_provision_mysql_no_url(self): """ Don't provision a mysql database if INSTANCE_MYSQL_URL is not set """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_mysql() databases = subprocess.check_output( "mysql -u root -e 'SHOW DATABASES'", shell=True).decode() for database in instance.mysql_database_names: self.assertNotIn(database, databases)
def test_github_admin_username_list_with_org_set(self, mock_get_username_list): """ When an admin org is set, its members should be included in the ansible conf """ mock_get_username_list.return_value = ['admin1', 'admin2'] instance = OpenEdXInstanceFactory(github_admin_organization_name='test-admin-org') instance.reset_ansible_settings() self.assertEqual(instance.github_admin_username_list, ['admin1', 'admin2']) self.assertIn('COMMON_USER_INFO:\n - name: admin1\n github: true\n type: admin\n' ' - name: admin2\n github: true\n type: admin', instance.ansible_settings)
def test_set_to_branch_tip_replace_commit_hash( self, mock_get_commit_id_from_ref): """ The hash should be updated in the instance name when updating """ mock_get_commit_id_from_ref.return_value = '1234567' + 'd' * 33 instance = OpenEdXInstanceFactory(commit_id='a' * 40, name='Test Instance (aaaaaaa)') instance.set_to_branch_tip(branch_name='new-branch', ref_type='tag') self.assertEqual(instance.name, 'Test Instance (1234567)')
def test_log_text(self): """ Check `log_text` output for combination of instance & server logs """ instance = OpenEdXInstanceFactory() server = OpenStackServerFactory(instance=instance) with freeze_time("2015-08-05 18:07:00"): instance.log('info', 'Line #1, on instance') with freeze_time("2015-08-05 18:07:01"): server.log('info', 'Line #2, on server') with freeze_time("2015-08-05 18:07:02"): instance.log('debug', 'Line #3, on instance (debug, not published by default)') with freeze_time("2015-08-05 18:07:03"): instance.log('info', 'Line #4, on instance') with freeze_time("2015-08-05 18:07:04"): instance.log('warn', 'Line #5, on instance (warn)') with freeze_time("2015-08-05 18:07:05"): server.log('info', 'Line #6, on server') with freeze_time("2015-08-05 18:07:06"): server.log('exception', 'Line #7, on server (exception)') self.assertEqual(instance.log_text, ( "2015-08-05 18:07:00 [info] Line #1, on instance\n" "2015-08-05 18:07:01 [info] Line #2, on server\n" "2015-08-05 18:07:03 [info] Line #4, on instance\n" "2015-08-05 18:07:04 [warn] Line #5, on instance (warn)\n" "2015-08-05 18:07:05 [info] Line #6, on server\n" "2015-08-05 18:07:06 [exception] Line #7, on server (exception)\n"))
def test_provision_mysql_weird_domain(self): """ Make sure that database names are escaped correctly """ sub_domain = 'really.really.really.really.long.subdomain' base_domain = 'this-is-a-really-long-unusual-domain-แปลกมาก.com' instance = OpenEdXInstanceFactory(use_ephemeral_databases=False, sub_domain=sub_domain, base_domain=base_domain) instance.provision_mysql() self.check_mysql(instance)
def test_provision_mongo_no_url(self): """ Don't provision any mongo databases if INSTANCE_MONGO_URL is not set """ mongo = pymongo.MongoClient(settings.INSTANCE_MONGO_URL) with override_settings(INSTANCE_MONGO_URL=None): instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_mongo() databases = mongo.database_names() for database in instance.mongo_database_names: self.assertNotIn(database, databases)
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)
def test_set_to_branch_tip_no_commit(self, mock_get_commit_id_from_ref): """ Set the commit id to the tip of the current branch, with commit=False """ mock_get_commit_id_from_ref.return_value = 'b' * 40 instance = OpenEdXInstanceFactory(commit_id='a' * 40) instance.set_to_branch_tip(commit=False) self.assertEqual(instance.commit_id, 'b' * 40) # Check values in DB db_instance = OpenEdXInstance.objects.get(pk=instance.pk) self.assertEqual(db_instance.commit_id, 'a' * 40)
def test_provision_swift(self, mock_swift_connection): """ Test provisioning Swift containers, and that they are provisioned only once. """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_swift() self.check_swift(instance, mock_swift_connection) # Provision again without resetting the mock. The assertCountEqual assertion will verify # that the container isn't provisioned again. instance.provision_swift() self.check_swift(instance, mock_swift_connection)
def test_set_fork_name_commit(self): """ Set org & repo using the fork name - Using the default commit policy (True) """ instance = OpenEdXInstanceFactory() instance.set_fork_name('org2/another-repo') self.assertEqual(instance.github_organization_name, 'org2') self.assertEqual(instance.github_repository_name, 'another-repo') # Check values in DB db_instance = OpenEdXInstance.objects.get(pk=instance.pk) self.assertEqual(db_instance.github_organization_name, 'org2') self.assertEqual(db_instance.github_repository_name, 'another-repo')
def test_ansible_extra_settings(self): """ Add extra settings in ansible vars, which can override existing settings """ instance = OpenEdXInstanceFactory( name='Vars Instance', email='*****@*****.**', ansible_extra_settings='EDXAPP_PLATFORM_NAME: "Overriden!"', ) instance.reset_ansible_settings() self.assertIn('EDXAPP_PLATFORM_NAME: Overriden!', instance.ansible_settings) self.assertNotIn('Vars Instance', instance.ansible_settings) self.assertIn("EDXAPP_CONTACT_EMAIL: [email protected]", instance.ansible_settings)
def test_ansible_settings_mysql(self): """ Add mysql ansible vars if INSTANCE_MYSQL_URL is set """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.reset_ansible_settings() self.assertIn('EDXAPP_MYSQL_USER: {0}'.format(instance.mysql_user), instance.ansible_settings) self.assertIn('EDXAPP_MYSQL_PASSWORD: {0}'.format(instance.mysql_pass), instance.ansible_settings) self.assertIn('EDXAPP_MYSQL_HOST: mysql.opencraft.com', instance.ansible_settings) self.assertIn('EDXAPP_MYSQL_PORT: 3306', instance.ansible_settings) self.assertIn('EDXAPP_MYSQL_DB_NAME: {0}'.format(instance.mysql_database_name), instance.ansible_settings) self.assertIn('COMMON_MYSQL_MIGRATE_USER: {0}'.format(instance.mysql_user), instance.ansible_settings) self.assertIn('COMMON_MYSQL_MIGRATE_PASS: {0}'.format(instance.mysql_pass), instance.ansible_settings)
def test_provision_mongo_again(self): """ Only create the databases once """ instance = OpenEdXInstanceFactory(use_ephemeral_databases=False) instance.provision_mongo() self.assertIs(instance.mongo_provisioned, True) mongo_user = instance.mongo_user mongo_pass = instance.mongo_pass instance.provision_mongo() self.assertEqual(instance.mongo_user, mongo_user) self.assertEqual(instance.mongo_pass, mongo_pass) self.check_mongo(instance)
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)
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)
def test_github_admin_username_list_with_org_set(self, mock_get_username_list): """ When an admin org is set, its members should be included in the ansible conf """ mock_get_username_list.return_value = ['admin1', 'admin2'] instance = OpenEdXInstanceFactory( github_admin_organization_name='test-admin-org') instance.reset_ansible_settings() self.assertEqual(instance.github_admin_username_list, ['admin1', 'admin2']) self.assertIn( 'COMMON_USER_INFO:\n - name: admin1\n github: true\n type: admin\n' ' - name: admin2\n github: true\n type: admin', instance.ansible_settings)
def test_set_fork_name_no_commit(self): """ Set org & repo using the fork name, with commit=False """ instance = OpenEdXInstanceFactory( github_organization_name='open-craft', github_repository_name='edx', ) instance.set_fork_name('org2/another-repo', commit=False) self.assertEqual(instance.github_organization_name, 'org2') self.assertEqual(instance.github_repository_name, 'another-repo') # Check values in DB db_instance = OpenEdXInstance.objects.get(pk=instance.pk) self.assertEqual(db_instance.github_organization_name, 'open-craft') self.assertEqual(db_instance.github_repository_name, 'edx')
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)
def test_get_log_entries(self): """ GET - Log entries """ self.api_client.login(username='******', password='******') instance = OpenEdXInstanceFactory(sub_domain='instance0') server = OpenStackServerFactory(openstack_id="vm0", instance=instance) instance.logger.info("info") instance.logger.error("error") server.logger.info("info") server.logger.error("error") response = self.api_client.get('/api/v1/openedxinstance/{pk}/'.format(pk=instance.pk)) self.assertEqual(response.status_code, status.HTTP_200_OK) expected_list = [ {'level': 'INFO', 'text': 'instance.models.instance | instance=instance0 | info'}, {'level': 'ERROR', 'text': 'instance.models.instance | instance=instance0 | error'}, {'level': 'INFO', 'text': 'instance.models.server | instance=instance0,server=vm0 | info'}, {'level': 'ERROR', 'text': 'instance.models.server | instance=instance0,server=vm0 | error'}, ] self.assertEqual(len(expected_list), len(response.data['log_entries'])) for expected_entry, log_entry in zip(expected_list, response.data['log_entries']): self.assertEqual(expected_entry['level'], log_entry['level']) self.assertEqual(expected_entry['text'], log_entry['text'])
def setUp(self): """ Set up an instance and server to use for testing. """ super().setUp() self.instance = OpenEdXInstanceFactory(sub_domain='my.instance') self.server = OpenStackServerFactory(instance=self.instance, openstack_id='vm1_id')
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)
def test_inventory_str(self, os_server_manager): """ Ansible inventory - showing servers once they are in booted status """ instance = OpenEdXInstanceFactory() self.assertEqual(instance.inventory_str, '[app]') # Server 1: 'started' StartedOpenStackServerFactory(instance=instance) self.assertEqual(instance.inventory_str, '[app]') # Server 2: 'booted' server2 = BootedOpenStackServerFactory(instance=instance) os_server_manager.add_fixture(server2.openstack_id, 'openstack/api_server_2_active.json') self.assertEqual(instance.inventory_str, '[app]') # Server 3: 'provisioning' server3 = ProvisioningOpenStackServerFactory(instance=instance) os_server_manager.add_fixture(server3.openstack_id, 'openstack/api_server_2_active.json') self.assertEqual(instance.inventory_str, '[app]\n192.168.100.200') # Server 4: 'provisioning' server4 = ProvisioningOpenStackServerFactory(instance=instance) os_server_manager.add_fixture(server4.openstack_id, 'openstack/api_server_3_active.json') self.assertEqual(instance.inventory_str, '[app]\n192.168.100.200\n192.168.99.66')
def test_ansible_playbook_filename(self): """ Set name of ansible playbook & get filename """ instance = OpenEdXInstanceFactory( ansible_playbook_name='test_playbook') self.assertEqual(instance.ansible_playbook_filename, 'test_playbook.yml')
def test_reset_ansible_settings(self): """ Ansible vars as a string """ instance = OpenEdXInstanceFactory( name='Vars Instance', sub_domain='vars.test', email='*****@*****.**', github_organization_name='vars-org', github_repository_name='vars-repo', commit_id='9' * 40, ansible_source_repo_url='http://example.org/config/repo', configuration_version='test-config-ver', forum_version='test-forum-ver', notifier_version='test-notif-ver', xqueue_version='test-xq-ver', certs_version='test-cert-ver', ) instance.reset_ansible_settings() self.assertIn('EDXAPP_PLATFORM_NAME: "Vars Instance"', instance.ansible_settings) self.assertIn("EDXAPP_SITE_NAME: 'vars.test.example.com", instance.ansible_settings) self.assertIn("EDXAPP_CMS_SITE_NAME: 'studio.vars.test.example.com'", instance.ansible_settings) self.assertIn("EDXAPP_CONTACT_EMAIL: '*****@*****.**'", instance.ansible_settings) self.assertIn( "edx_platform_repo: 'https://github.com/vars-org/vars-repo.git'", instance.ansible_settings) self.assertIn("edx_platform_version: '{}'".format('9' * 40), instance.ansible_settings) self.assertIn( "edx_ansible_source_repo: 'http://example.org/config/repo'", instance.ansible_settings) self.assertIn("configuration_version: 'test-config-ver'", instance.ansible_settings) self.assertIn("forum_version: 'test-forum-ver'", instance.ansible_settings) self.assertIn("notifier_version: 'test-notif-ver'", instance.ansible_settings) self.assertIn("xqueue_version: 'test-xq-ver'", instance.ansible_settings) self.assertIn("certs_version: 'test-cert-ver'", instance.ansible_settings)