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_mongo(self):
"""
Provision mongo databases
"""
instance = OpenEdXInstanceFactory(use_ephemeral_databases=False)
instance.provision_mongo()
self.check_mongo(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_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_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_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_provision_mysql(self):
"""
Provision mysql database
"""
instance = OpenEdXInstanceFactory(use_ephemeral_databases=False)
instance.provision_mysql()
self.check_mysql(instance)
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_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_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_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_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_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_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_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_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_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_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_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_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)
