Python OpenEdXInstanceFactory.load_balancing_server方法代码示例

# 需要导入模块: from instance.tests.models.factories.openedx_instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.openedx_instance.OpenEdXInstanceFactory import load_balancing_server [as 别名]
    def test_shut_down(self, mock_reconfigure, mock_disable_monitoring, mock_remove_dns_records):
        """
        Test that `shut_down` method terminates all app servers belonging to an instance
        and disables monitoring.
        """
        instance = OpenEdXInstanceFactory()
        instance.load_balancing_server = LoadBalancingServer.objects.select_random()
        instance.save()
        reference_date = timezone.now()

        # Create app servers
        obsolete_appserver = self._create_running_appserver(instance, reference_date - timedelta(days=5))
        obsolete_appserver_failed = self._create_failed_appserver(instance, reference_date - timedelta(days=5))

        recent_appserver = self._create_running_appserver(instance, reference_date - timedelta(days=1))
        recent_appserver_failed = self._create_failed_appserver(instance, reference_date - timedelta(days=1))

        active_appserver = self._create_running_appserver(instance, reference_date)

        newer_appserver = self._create_running_appserver(instance, reference_date + timedelta(days=3))
        newer_appserver_failed = self._create_failed_appserver(instance, reference_date + timedelta(days=3))

        # Set single app server active
        instance.active_appserver = active_appserver
        instance.save()
        active_appserver.instance.refresh_from_db()

        self.assertEqual(mock_reconfigure.call_count, 0)
        self.assertEqual(mock_disable_monitoring.call_count, 0)
        self.assertEqual(mock_remove_dns_records.call_count, 0)

        # Shut down instance
        instance.shut_down()

        self.assertEqual(mock_reconfigure.call_count, 1)
        self.assertEqual(mock_disable_monitoring.call_count, 1)
        self.assertEqual(mock_remove_dns_records.call_count, 1)

        # Check status of running app servers
        self._assert_status([
            (obsolete_appserver, AppServerStatus.Terminated, ServerStatus.Terminated),
            (recent_appserver, AppServerStatus.Terminated, ServerStatus.Terminated),
            (active_appserver, AppServerStatus.Terminated, ServerStatus.Terminated),
            (newer_appserver, AppServerStatus.Terminated, ServerStatus.Terminated),
        ])

        # Check status of failed app servers:
        # AppServerStatus.Terminated is reserved for instances that were running successfully at some point,
        # so app servers with AppServerStatus.ConfigurationFailed will still have that status
        # after `shut_down` calls `terminate_vm` on them.
        # However, the VM (OpenStackServer) that an app server is associated with
        # *should* have ServerStatus.Terminated if the app server was old enough to be terminated.
        self._assert_status([
            (obsolete_appserver_failed, AppServerStatus.ConfigurationFailed, ServerStatus.Terminated),
            (recent_appserver_failed, AppServerStatus.ConfigurationFailed, ServerStatus.Terminated),
            (newer_appserver_failed, AppServerStatus.ConfigurationFailed, ServerStatus.Terminated),
        ])

# 需要导入模块: from instance.tests.models.factories.openedx_instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.openedx_instance.OpenEdXInstanceFactory import load_balancing_server [as 别名]
def make_test_appserver(instance=None):
    """
    Factory method to create an OpenEdXAppServer (and OpenStackServer).
    """
    if not instance:
        instance = OpenEdXInstanceFactory()
    if not instance.load_balancing_server:
        instance.load_balancing_server = LoadBalancingServer.objects.select_random()
        instance.save()
    return instance._create_owned_appserver()

# 需要导入模块: from instance.tests.models.factories.openedx_instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.openedx_instance.OpenEdXInstanceFactory import load_balancing_server [as 别名]
 def test_set_dns_records(self):
     """
     Test set_dns_records() without external domains.
     """
     instance = OpenEdXInstanceFactory(internal_lms_domain='test.dns.example.com',
                                       use_ephemeral_databases=True)
     instance.load_balancing_server = LoadBalancingServer.objects.select_random()
     instance.save()
     instance.set_dns_records()
     self._verify_dns_records(instance, 'example.com')

# 需要导入模块: from instance.tests.models.factories.openedx_instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.openedx_instance.OpenEdXInstanceFactory import load_balancing_server [as 别名]
 def test_remove_dns_records(self):
     """
     Test remove_dns_records().
     """
     instance = OpenEdXInstanceFactory(internal_lms_domain='test.dns.opencraft.co.uk')
     instance.load_balancing_server = LoadBalancingServer.objects.select_random()
     instance.save()
     instance.set_dns_records()
     instance.remove_dns_records()
     dns_records = gandi.api.client.list_records('opencraft.co.uk')
     self.assertEqual(dns_records, [])

# 需要导入模块: from instance.tests.models.factories.openedx_instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.openedx_instance.OpenEdXInstanceFactory import load_balancing_server [as 别名]
 def test_set_dns_records_external_domain(self):
     """
     Test set_dns_records() with custom external domains.
     Ensure that the DNS records are only created for the internal domains.
     """
     instance = OpenEdXInstanceFactory(internal_lms_domain='test.dns.opencraft.co.uk',
                                       external_lms_domain='courses.myexternal.org',
                                       external_lms_preview_domain='preview.myexternal.org',
                                       external_studio_domain='studio.myexternal.org',
                                       use_ephemeral_databases=True)
     instance.load_balancing_server = LoadBalancingServer.objects.select_random()
     instance.save()
     instance.set_dns_records()
     self._verify_dns_records(instance, 'opencraft.co.uk')

# 需要导入模块: from instance.tests.models.factories.openedx_instance import OpenEdXInstanceFactory [as 别名]
# 或者: from instance.tests.models.factories.openedx_instance.OpenEdXInstanceFactory import load_balancing_server [as 别名]
 def test_shut_down_no_active_appserver(self, mock_reconfigure, mock_disable_monitoring, mock_remove_dns_records):
     """
     Test that the shut_down method works correctly if no appserver is active.
     """
     instance = OpenEdXInstanceFactory()
     instance.load_balancing_server = LoadBalancingServer.objects.select_random()
     instance.save()
     appserver = self._create_running_appserver(instance)
     instance.shut_down()
     self.assertEqual(mock_reconfigure.call_count, 1)
     self.assertEqual(mock_disable_monitoring.call_count, 0)
     self.assertEqual(mock_remove_dns_records.call_count, 1)
     self._assert_status([
         (appserver, AppServerStatus.Terminated, ServerStatus.Terminated)
     ])