def test_check_expired_when_not_expired(self):
"""Testing IntegrationManager.check_expired when not expired"""
manager = IntegrationManager(IntegrationConfig)
# Cache some state.
integration = manager.register_integration_class(DummyIntegration1)
integration.create_config(enabled=True, save=True)
manager.get_integration_configs(DummyIntegration1)
# Make sure the integration isn't enabled. This would be because we
# haven't refreshed yet.
self.assertFalse(integration.enabled)
self.assertNotEqual(manager._integration_configs, {})
# Fake having the latest state.
manager._needs_recalc = False
# Check expired state, without actually expiring it.
self.assertFalse(manager.is_expired())
manager.check_expired()
# Make sure state has not changed.
self.assertFalse(manager.is_expired())
self.assertFalse(integration.enabled)
self.assertNotEqual(manager._integration_configs, {})
def test_check_expired_when_expired(self):
"""Testing IntegrationManager.check_expired when expired"""
manager = IntegrationManager(IntegrationConfig)
# Cache some state.
integration1 = manager.register_integration_class(DummyIntegration1)
integration1.create_config(enabled=True, save=True)
manager.get_integration_configs(DummyIntegration1)
integration2 = manager.register_integration_class(DummyIntegration2)
manager.get_integration_configs(DummyIntegration1)
# Make sure the integration isn't enabled. This would be because we
# haven't refreshed yet.
self.assertFalse(integration1.enabled)
self.assertFalse(integration2.enabled)
self.assertNotEqual(manager._integration_configs, {})
# Check expired state.
self.assertTrue(manager.is_expired())
manager.check_expired()
# Make sure state has been updated and caches cleared.
self.assertTrue(integration1.enabled)
self.assertFalse(integration2.enabled)
self.assertEqual(manager._integration_configs, {})
def test_is_expired_after_config_deleted(self):
"""Testing IntegrationManager.is_expired after config deleted"""
manager = IntegrationManager(IntegrationConfig)
self.assertFalse(manager.is_expired())
post_delete.send(sender=IntegrationConfig)
self.assertTrue(manager.is_expired())
def test_is_expired_after_config_deleted(self):
"""Testing IntegrationManager.is_expired after config deleted"""
manager = IntegrationManager(IntegrationConfig)
self.assertFalse(manager.is_expired())
post_delete.send(sender=IntegrationConfig)
self.assertTrue(manager.is_expired())
def test_register_integration_class_with_construct_error(self):
"""Testing IntegrationManager.register_integration_class with
construction error
"""
manager = IntegrationManager(IntegrationConfig)
with self.assertRaises(IntegrationRegistrationError):
manager.register_integration_class(BrokenIntegration)
def test_unregister_integration_class_with_unregistered(self):
"""Testing IntegrationManager.unregister_integration_class with
unregistered integration
"""
manager = IntegrationManager(IntegrationConfig)
with self.assertRaises(IntegrationNotRegisteredError):
manager.unregister_integration_class(DummyIntegration1)
def test_unregister_integration_class_with_unregistered(self):
"""Testing IntegrationManager.unregister_integration_class with
unregistered integration
"""
manager = IntegrationManager(IntegrationConfig)
with self.assertRaises(IntegrationNotRegisteredError):
manager.unregister_integration_class(DummyIntegration1)
def test_get_integration_classes(self):
"""Testing IntegrationManager.get_integration_classes"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
manager.register_integration_class(DummyIntegration2)
classes = manager.get_integration_classes()
self.assertEqual(set(classes), {DummyIntegration1, DummyIntegration2})
def test_register_integration_class_with_construct_error(self):
"""Testing IntegrationManager.register_integration_class with
construction error
"""
manager = IntegrationManager(IntegrationConfig)
with self.assertRaises(IntegrationRegistrationError):
manager.register_integration_class(BrokenIntegration)
def setUp(self):
super(IntegrationConfigTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration1)
self.config = self.integration.create_config()
self.config.manager = self.manager
def test_shutdown_integration_managers(self):
"""Testing shutdown_integration_managers"""
IntegrationManager(IntegrationConfig)
IntegrationManager(IntegrationConfig)
shutdown_integration_managers()
self.assertEqual(get_integration_managers(), [])
def test_get_integration_classes(self):
"""Testing IntegrationManager.get_integration_classes"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
manager.register_integration_class(DummyIntegration2)
classes = manager.get_integration_classes()
self.assertEqual(set(classes), {DummyIntegration1, DummyIntegration2})
def test_register_integration_class_with_already_registered(self):
"""Testing IntegrationManager.register_integration_class with
already registered class
"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
with self.assertRaises(IntegrationAlreadyRegisteredError):
manager.register_integration_class(DummyIntegration1)
def test_unregister_integration_class(self):
"""Testing IntegrationManager.unregister_integration_class"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
manager.unregister_integration_class(DummyIntegration1)
integration_id = DummyIntegration1.integration_id
self.assertNotIn(integration_id, manager._integration_classes)
self.assertNotIn(integration_id, manager._integration_instances)
def test_check_expired_when_not_expired(self):
"""Testing IntegrationManager.check_expired when not expired"""
manager = IntegrationManager(IntegrationConfig)
# Cache some state.
integration = manager.register_integration_class(DummyIntegration1)
integration.create_config(enabled=True, save=True)
manager.get_integration_configs(DummyIntegration1)
# Make sure the integration isn't enabled. This would be because we
# haven't refreshed yet.
self.assertFalse(integration.enabled)
self.assertNotEqual(manager._integration_configs, {})
# Fake having the latest state.
manager._needs_recalc = False
# Check expired state, without actually expiring it.
self.assertFalse(manager.is_expired())
manager.check_expired()
# Make sure state has not changed.
self.assertFalse(manager.is_expired())
self.assertFalse(integration.enabled)
self.assertNotEqual(manager._integration_configs, {})
def test_get_integration(self):
"""Testing IntegrationManager.get_integration"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
manager.register_integration_class(DummyIntegration2)
integration = manager.get_integration(DummyIntegration1.integration_id)
self.assertEqual(integration.__class__, DummyIntegration1)
integration = manager.get_integration(DummyIntegration2.integration_id)
self.assertEqual(integration.__class__, DummyIntegration2)
def test_is_expired_after_other_process_updates(self):
"""Testing IntegrationManager.is_expired after another process updates
the configuration state
"""
manager = IntegrationManager(IntegrationConfig)
self.assertFalse(manager.is_expired())
gen_sync = GenerationSynchronizer(manager._gen_sync.cache_key, normalize_cache_key=False)
gen_sync.mark_updated()
self.assertTrue(manager.is_expired())
def test_is_expired_after_other_process_updates(self):
"""Testing IntegrationManager.is_expired after another process updates
the configuration state
"""
manager = IntegrationManager(IntegrationConfig)
self.assertFalse(manager.is_expired())
gen_sync = GenerationSynchronizer(manager._gen_sync.cache_key,
normalize_cache_key=False)
gen_sync.mark_updated()
self.assertTrue(manager.is_expired())
def test_shutdown_integration_managers(self):
"""Testing shutdown_integration_managers"""
manager1 = IntegrationManager(IntegrationConfig)
self.assertTrue(manager1.enabled)
manager2 = IntegrationManager(IntegrationConfig)
self.assertTrue(manager2.enabled)
shutdown_integration_managers()
self.assertEqual(get_integration_managers(), [])
self.assertFalse(manager1.enabled)
self.assertFalse(manager2.enabled)
def test_get_integration_configs_with_filter(self):
"""Testing IntegrationManager.get_integration_configs with filter"""
manager = IntegrationManager(IntegrationConfig)
integration1 = manager.register_integration_class(DummyIntegration1)
integration2 = manager.register_integration_class(DummyIntegration2)
config1 = integration1.create_config(enabled=False, save=True)
integration1.create_config(enabled=True, save=True)
integration2.create_config(enabled=True, save=True)
with self.assertNumQueries(1):
configs = manager.get_integration_configs(integration1, enabled=False)
self.assertEqual(set(configs), {config1})
def test_clear_all_configs_cache(self):
"""Testing IntegrationManager.clear_all_configs_cache"""
manager = IntegrationManager(IntegrationConfig)
with self.assertNumQueries(1):
manager.get_integration_configs(DummyIntegration1)
with self.assertNumQueries(0):
manager.get_integration_configs(DummyIntegration1)
manager.clear_all_configs_cache()
with self.assertNumQueries(1):
manager.get_integration_configs(DummyIntegration1)
def test_register_integration_class(self):
"""Testing IntegrationManager.register_integration_class"""
manager = IntegrationManager(IntegrationConfig)
integration = manager.register_integration_class(DummyIntegration1)
self.assertEqual(integration.__class__, DummyIntegration1)
integration_id = DummyIntegration1.integration_id
self.assertEqual(integration_id, "djblets.integrations.tests.test_manager.DummyIntegration1")
self.assertIn(integration_id, manager._integration_classes)
self.assertEqual(manager._integration_classes[integration_id], DummyIntegration1)
self.assertIn(integration_id, manager._integration_instances)
self.assertEqual(manager._integration_instances[integration_id], integration)
def test_unregister_integration_class_with_enabled_integration(self):
"""Testing IntegrationManager.unregister_integration_class with
enabled integration
"""
manager = IntegrationManager(IntegrationConfig)
integration = manager.register_integration_class(DummyIntegration1)
integration_id = DummyIntegration1.integration_id
integration.enabled = True
manager.unregister_integration_class(DummyIntegration1)
self.assertFalse(integration.enabled)
self.assertNotIn(integration_id, manager._integration_classes)
self.assertNotIn(integration_id, manager._integration_instances)
def test_get_integration_configs_caches(self):
"""Testing IntegrationManager.get_integration_configs caches results"""
manager = IntegrationManager(IntegrationConfig)
integration1 = manager.register_integration_class(DummyIntegration1)
config1 = integration1.create_config(enabled=True, save=True)
config2 = integration1.create_config(enabled=False, save=True)
with self.assertNumQueries(1):
manager.get_integration_configs()
with self.assertNumQueries(0):
configs = manager.get_integration_configs()
self.assertEqual(set(configs), {config1, config2})
def test_unregister_integration_class_with_enabled_integration(self):
"""Testing IntegrationManager.unregister_integration_class with
enabled integration
"""
manager = IntegrationManager(IntegrationConfig)
integration = manager.register_integration_class(DummyIntegration1)
integration_id = DummyIntegration1.integration_id
integration.enabled = True
manager.unregister_integration_class(DummyIntegration1)
self.assertFalse(integration.enabled)
self.assertNotIn(integration_id, manager._integration_classes)
self.assertNotIn(integration_id, manager._integration_instances)
def test_get_integration_configs_with_filter(self):
"""Testing IntegrationManager.get_integration_configs with filter"""
manager = IntegrationManager(IntegrationConfig)
integration1 = manager.register_integration_class(DummyIntegration1)
integration2 = manager.register_integration_class(DummyIntegration2)
config1 = integration1.create_config(enabled=False, save=True)
integration1.create_config(enabled=True, save=True)
integration2.create_config(enabled=True, save=True)
with self.assertNumQueries(1):
configs = manager.get_integration_configs(integration1,
enabled=False)
self.assertEqual(set(configs), {config1})
class IntegrationConfigTests(IntegrationsTestCase):
"""Unit tests for djblets.integrations.models.BaseIntegrationConfig."""
def setUp(self):
super(IntegrationConfigTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration1)
self.config = self.integration.create_config()
self.config.manager = self.manager
def test_integration(self):
"""Testing BaseIntegrationConfig.integration"""
self.assertEqual(self.config.integration, self.integration)
def test_get(self):
"""Testing BaseIntegrationConfig.get"""
self.config.settings['foo'] = 'bar'
self.assertEqual(self.config.get('foo'), 'bar')
def test_get_with_integration_defaults(self):
"""Testing BaseIntegrationConfig.get with integration defaults"""
self.assertEqual(self.config.get('foo'), 'default-foo')
def test_get_with_default(self):
"""Testing BaseIntegrationConfig.get with default"""
self.assertEqual(self.config.get('new-key', 'my-default'),
'my-default')
def test_set(self):
"""Testing BaseIntegrationConfig.set"""
self.config.set('my-key', 'my-value')
self.assertEqual(self.config.settings.get('my-key'), 'my-value')
class IntegrationConfigTests(IntegrationsTestCase):
"""Unit tests for djblets.integrations.models.BaseIntegrationConfig."""
def setUp(self):
super(IntegrationConfigTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration1)
self.config = self.integration.create_config()
self.config.manager = self.manager
def test_integration(self):
"""Testing BaseIntegrationConfig.integration"""
self.assertEqual(self.config.integration, self.integration)
def test_get(self):
"""Testing BaseIntegrationConfig.get"""
self.config.settings['foo'] = 'bar'
self.assertEqual(self.config.get('foo'), 'bar')
def test_get_with_integration_defaults(self):
"""Testing BaseIntegrationConfig.get with integration defaults"""
self.assertEqual(self.config.get('foo'), 'default-foo')
def test_get_with_default(self):
"""Testing BaseIntegrationConfig.get with default"""
self.assertEqual(self.config.get('new-key', 'my-default'),
'my-default')
def test_set(self):
"""Testing BaseIntegrationConfig.set"""
self.config.set('my-key', 'my-value')
self.assertEqual(self.config.settings.get('my-key'), 'my-value')
def test_get_integration_configs(self):
"""Testing IntegrationManager.get_integration_configs with all
configurations
"""
manager = IntegrationManager(IntegrationConfig)
integration1 = manager.register_integration_class(DummyIntegration1)
integration2 = manager.register_integration_class(DummyIntegration2)
config1 = integration1.create_config(enabled=True, save=True)
config2 = integration1.create_config(enabled=False, save=True)
config3 = integration2.create_config(enabled=True, save=True)
with self.assertNumQueries(1):
configs = manager.get_integration_configs()
self.assertEqual(set(configs), {config1, config2, config3})
def test_get_integration_configs(self):
"""Testing IntegrationManager.get_integration_configs with all
configurations
"""
manager = IntegrationManager(IntegrationConfig)
integration1 = manager.register_integration_class(DummyIntegration1)
integration2 = manager.register_integration_class(DummyIntegration2)
config1 = integration1.create_config(enabled=True, save=True)
config2 = integration1.create_config(enabled=False, save=True)
config3 = integration2.create_config(enabled=True, save=True)
with self.assertNumQueries(1):
configs = manager.get_integration_configs()
self.assertEqual(set(configs), {config1, config2, config3})
def setUp(self):
super(IntegrationConfigTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration1)
self.config = self.integration.create_config()
self.config.manager = self.manager
def test_clear_all_configs_cache(self):
"""Testing IntegrationManager.clear_all_configs_cache"""
manager = IntegrationManager(IntegrationConfig)
with self.assertNumQueries(1):
manager.get_integration_configs(DummyIntegration1)
with self.assertNumQueries(0):
manager.get_integration_configs(DummyIntegration1)
manager.clear_all_configs_cache()
with self.assertNumQueries(1):
manager.get_integration_configs(DummyIntegration1)
def test_register_integration_class(self):
"""Testing IntegrationManager.register_integration_class"""
manager = IntegrationManager(IntegrationConfig)
integration = manager.register_integration_class(DummyIntegration1)
self.assertEqual(integration.__class__, DummyIntegration1)
integration_id = DummyIntegration1.integration_id
self.assertEqual(
integration_id,
'djblets.integrations.tests.test_manager.DummyIntegration1')
self.assertIn(integration_id, manager._integration_classes)
self.assertEqual(manager._integration_classes[integration_id],
DummyIntegration1)
self.assertIn(integration_id, manager._integration_instances)
self.assertEqual(manager._integration_instances[integration_id],
integration)
def setUp(self):
super(IntegrationHookTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
# This will make this class a hook owner.
self.hooks = set()
self.hook = DummyIntegrationHook(self.manager, self, DummyIntegration)
def setUp(self):
super(IntegrationConfigFormTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration)
request_factory = RequestFactory()
self.request = request_factory.get('/getSomeForm/')
self.form = IntegrationConfigForm(integration=self.integration,
request=self.request,
instance=None,
data={
'enabled': True,
'name': 'FakeName',
})
self.form.full_clean()
self.form.save()
def test_init_without_app(self):
"""Testing IntegrationManager initialization without INSTALLED_APPS"""
msg = ('IntegrationManager requires djblets.integrations to be '
'listed in settings.INSTALLED_APPS.')
installed_apps = list(settings.INSTALLED_APPS)
installed_apps.remove('djblets.integrations')
with self.settings(INSTALLED_APPS=installed_apps):
with self.assertRaisesMessage(ImproperlyConfigured, msg):
IntegrationManager(IntegrationConfig)
def test_register_integration_class_with_already_registered(self):
"""Testing IntegrationManager.register_integration_class with
already registered class
"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
with self.assertRaises(IntegrationAlreadyRegisteredError):
manager.register_integration_class(DummyIntegration1)
def get_integration_manager():
"""Return the integration manager for Review Board.
Returns:
djblets.integrations.manager.IntegrationManager:
The integration manager used for Review Board.
"""
global _integration_manager
if not _integration_manager:
from reviewboard.integrations.models import IntegrationConfig
_integration_manager = IntegrationManager(IntegrationConfig)
return _integration_manager
def test_init_without_middleware(self):
"""Testing IntegrationManager initialization without
MIDDLEWARE_CLASSES
"""
msg = ('IntegrationManager requires djblets.integrations.middleware.'
'IntegrationsMiddleware to be listed in '
'settings.MIDDLEWARE_CLASSES')
middleware_classes = list(settings.MIDDLEWARE_CLASSES)
middleware_classes.remove('djblets.integrations.middleware.'
'IntegrationsMiddleware')
with self.settings(MIDDLEWARE_CLASSES=middleware_classes):
with self.assertRaisesMessage(ImproperlyConfigured, msg):
IntegrationManager(IntegrationConfig)
def test_unregister_integration_class(self):
"""Testing IntegrationManager.unregister_integration_class"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
manager.unregister_integration_class(DummyIntegration1)
integration_id = DummyIntegration1.integration_id
self.assertNotIn(integration_id, manager._integration_classes)
self.assertNotIn(integration_id, manager._integration_instances)
def test_get_integration(self):
"""Testing IntegrationManager.get_integration"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
manager.register_integration_class(DummyIntegration2)
integration = manager.get_integration(DummyIntegration1.integration_id)
self.assertEqual(integration.__class__, DummyIntegration1)
integration = manager.get_integration(DummyIntegration2.integration_id)
self.assertEqual(integration.__class__, DummyIntegration2)
class IntegrationConfigTests(IntegrationsTestCase):
"""Unit tests for djblets.integrations.models.BaseIntegrationConfig."""
def setUp(self):
super(IntegrationConfigTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration1)
self.config = self.integration.create_config(name='Test Config')
self.config.manager = self.manager
def test_integration(self):
"""Testing BaseIntegrationConfig.integration"""
self.assertEqual(self.config.integration, self.integration)
def test_get(self):
"""Testing BaseIntegrationConfig.get"""
self.config.settings['foo'] = 'bar'
self.assertEqual(self.config.get('foo'), 'bar')
def test_get_with_integration_defaults(self):
"""Testing BaseIntegrationConfig.get with integration defaults"""
self.assertEqual(self.config.get('foo'), 'default-foo')
def test_get_with_default(self):
"""Testing BaseIntegrationConfig.get with default"""
self.assertEqual(self.config.get('new-key', 'my-default'),
'my-default')
def test_set(self):
"""Testing BaseIntegrationConfig.set"""
self.config.set('my-key', 'my-value')
self.assertEqual(self.config.settings.get('my-key'), 'my-value')
def test_str_with_available_integration(self):
"""Testing BaseIntegrationConfig.__str__ with available integration"""
self.assertEqual(six.text_type(self.config), 'Test Config (Dummy)')
def test_str_without_available_integration(self):
"""Testing BaseIntegrationConfig.__str__ without available integration
"""
self.config.integration_id = 'foo.bar.BadIntegration'
self.assertEqual(six.text_type(self.config),
'Test Config (foo.bar.BadIntegration)')
class IntegrationConfigFormTests(IntegrationsTestCase):
"""Unit tests for djblets.integrations.forms.IntegrationConfigForm."""
def setUp(self):
super(IntegrationConfigFormTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration)
request_factory = RequestFactory()
self.request = request_factory.get('/getSomeForm/')
self.form = IntegrationConfigForm(integration=self.integration,
request=self.request,
instance=None,
data={
'enabled': True,
'name': 'FakeName',
})
self.form.full_clean()
self.form.save()
def test_config(self):
"""Testing IntegrationConfigForm.config returns the config instance"""
self.assertIsInstance(self.form.config, IntegrationConfig)
def test_get_key_value_model_field(self):
"""Testing IntegrationConfigForm.get_key_value() returns values from
form data"""
self.assertEqual(self.form.get_key_value('name'), 'FakeName')
self.assertTrue(self.form.get_key_value('enabled'))
def test_set_key_value_model_field(self):
"""Testing IntegrationConfigForm.set_key_value() overrides form
data"""
name_field = 'name'
expected_value = 'NewName'
self.form.set_key_value(name_field, expected_value)
self.assertEqual(self.form.get_key_value(name_field), expected_value)
def test_set_key_value_non_model_field(self):
"""Testing IntegrationConfigForm.set_key_value() sets custom non-field
data"""
test_field = 'new_non_model_field'
self.form.set_key_value(test_field, True)
self.assertTrue(self.form.get_key_value(test_field))
def test_shutdown(self):
"""Testing IntegrationManager.shutdown"""
manager = IntegrationManager(IntegrationConfig)
instance = manager.register_integration_class(DummyIntegration1)
instance.enable_integration()
self.assertTrue(instance.enabled)
self.assertNotEqual(manager._integration_classes, {})
self.assertNotEqual(manager._integration_instances, {})
self.assertTrue(manager.is_expired())
manager.shutdown()
self.assertFalse(instance.enabled)
self.assertEqual(manager._integration_classes, {})
self.assertEqual(manager._integration_instances, {})
self.assertFalse(manager.is_expired())
def test_get_integration_configs_caches(self):
"""Testing IntegrationManager.get_integration_configs caches results"""
manager = IntegrationManager(IntegrationConfig)
integration1 = manager.register_integration_class(DummyIntegration1)
config1 = integration1.create_config(enabled=True, save=True)
config2 = integration1.create_config(enabled=False, save=True)
with self.assertNumQueries(1):
manager.get_integration_configs()
with self.assertNumQueries(0):
configs = manager.get_integration_configs()
self.assertEqual(set(configs), {config1, config2})
def test_shutdown(self):
"""Testing IntegrationManager.shutdown"""
manager = IntegrationManager(IntegrationConfig)
instance = manager.register_integration_class(DummyIntegration1)
instance.enable_integration()
self.assertTrue(instance.enabled)
self.assertNotEqual(manager._integration_classes, {})
self.assertNotEqual(manager._integration_instances, {})
self.assertTrue(manager.is_expired())
manager.shutdown()
self.assertFalse(instance.enabled)
self.assertEqual(manager._integration_classes, {})
self.assertEqual(manager._integration_instances, {})
self.assertFalse(manager.is_expired())
def test_get_integration_with_invalid_id(self):
"""Testing IntegrationManager.get_integration with invalid ID"""
manager = IntegrationManager(IntegrationConfig)
with self.assertRaises(IntegrationNotRegisteredError):
manager.get_integration("foobar")
def test_is_expired_new_instance(self):
"""Testing IntegrationManager.is_expired on a new instance"""
manager = IntegrationManager(IntegrationConfig)
self.assertFalse(manager.is_expired())
def test_is_expired_after_registration(self):
"""Testing IntegrationManager.is_expired after new registration"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
self.assertTrue(manager.is_expired())
def test_get_integration_managers(self):
"""Testing get_integration_managers"""
manager1 = IntegrationManager(IntegrationConfig)
manager2 = IntegrationManager(IntegrationConfig)
self.assertEqual(set(get_integration_managers()), {manager1, manager2})
class IntegrationTests(IntegrationsTestCase):
"""Unit tests for djblets.integrations.integration.Integration."""
def setUp(self):
super(IntegrationTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration1)
def test_init(self):
"""Testing Integration initialization"""
self.assertEqual(self.integration.hooks, set())
self.assertFalse(self.integration.enabled)
self.assertFalse(hasattr(self.integration, 'dummy_initted'))
def test_id(self):
"""Testing Integration.id"""
self.assertEqual(self.integration.id, self.integration.integration_id)
def test_enable_integration(self):
"""Testing Integration.enable_integration"""
self.integration.enable_integration()
self.assertTrue(self.integration.enabled)
self.assertTrue(hasattr(self.integration, 'dummy_initted'))
self.assertTrue(self.integration.dummy_initted)
self.assertEqual(self.integration.hooks, {self.integration.hook})
def test_disable_integration(self):
"""Testing Integration.disable_integration"""
self.integration.enable_integration()
self.integration.disable_integration()
self.assertFalse(self.integration.enabled)
self.assertTrue(hasattr(self.integration, 'dummy_initted'))
self.assertFalse(self.integration.dummy_initted)
self.assertEqual(self.integration.hooks, set())
def test_get_configs(self):
"""Testing Integration.get_configs"""
config1 = self.integration.create_config(name='Config 1',
enabled=True,
save=True)
config2 = self.integration.create_config(name='Config 2',
enabled=True,
save=True)
# Add some configs that shouldn't be returned.
integration2 = \
self.manager.register_integration_class(DummyIntegration2)
self.integration.create_config(name='Config 3', save=True)
integration2.create_config(name='Config 4', save=True)
self.assertEqual(self.integration.get_configs(), [config1, config2])
def test_get_configs_with_filter(self):
"""Testing Integration.get_configs with filter"""
config1 = self.integration.create_config(name='Config 1',
enabled=True,
save=True)
self.integration.create_config(name='Config 2',
enabled=True,
save=True)
# Add some configs that shouldn't be returned.
integration2 = \
self.manager.register_integration_class(DummyIntegration2)
self.integration.create_config(name='Config 3', save=True)
integration2.create_config(name='Config 4', save=True)
self.assertEqual(self.integration.get_configs(name='Config 1'),
[config1])
def test_create_config(self):
"""Testing Integration.create_config"""
config = self.integration.create_config(name='Config 1')
self.assertFalse(config.enabled)
self.assertIsNone(config.pk)
def test_create_config_with_save(self):
"""Testing Integration.create_config with save=True"""
config = self.integration.create_config(name='Config 1', save=True)
self.assertFalse(config.enabled)
self.assertIsNotNone(config.pk)
def setUp(self):
super(IntegrationTests, self).setUp()
self.manager = IntegrationManager(IntegrationConfig)
self.integration = \
self.manager.register_integration_class(DummyIntegration1)
def test_is_expired_after_registration(self):
"""Testing IntegrationManager.is_expired after new registration"""
manager = IntegrationManager(IntegrationConfig)
manager.register_integration_class(DummyIntegration1)
self.assertTrue(manager.is_expired())
def test_check_expired_when_expired(self):
"""Testing IntegrationManager.check_expired when expired"""
manager = IntegrationManager(IntegrationConfig)
# Cache some state.
integration1 = manager.register_integration_class(DummyIntegration1)
integration1.create_config(enabled=True, save=True)
manager.get_integration_configs(DummyIntegration1)
integration2 = manager.register_integration_class(DummyIntegration2)
manager.get_integration_configs(DummyIntegration1)
# Make sure the integration isn't enabled. This would be because we
# haven't refreshed yet.
self.assertFalse(integration1.enabled)
self.assertFalse(integration2.enabled)
self.assertNotEqual(manager._integration_configs, {})
# Check expired state.
self.assertTrue(manager.is_expired())
manager.check_expired()
# Make sure state has been updated and caches cleared.
self.assertFalse(manager.is_expired())
self.assertTrue(integration1.enabled)
self.assertFalse(integration2.enabled)
self.assertEqual(manager._integration_configs, {})