def setUp(self):
class TestExtension(Extension):
"""An empty, dummy extension for testing"""
pass
self.key = 'test_key'
self.extension_class = TestExtension
self.manager = ExtensionManager(self.key)
self.fake_entrypoint = Mock()
self.fake_entrypoint.load = Mock(return_value=self.extension_class)
self.fake_entrypoint.dist = Mock()
self.test_author = 'Test author lorem ipsum'
self.test_description = 'Test description lorem ipsum'
self.test_email = 'Test [email protected]'
self.test_home_page = 'http://www.example.com'
self.test_license = 'Test License MIT GPL Apache Drivers'
self.test_module_name = 'testextension.dummy.dummy'
self.test_module_to_app = 'testextension.dummy'
self.test_project_name = 'TestProjectName'
self.test_summary = 'Test summary lorem ipsum'
self.test_version = '1.0'
self.test_htdocs_path = os.path.join(settings.EXTENSIONS_STATIC_ROOT,
self.test_project_name)
self.test_metadata = {
'Name': self.test_project_name,
'Version': self.test_version,
'Summary': self.test_summary,
'Description': self.test_description,
'Author': self.test_author,
'Author-email': self.test_email,
'License': self.test_license,
'Home-page': self.test_home_page,
}
self.fake_entrypoint.dist.get_metadata_lines = Mock(
return_value=[
"%s: %s" % (key, value)
for key, value in self.test_metadata.iteritems()
])
self.fake_entrypoint.dist.project_name = self.test_project_name
self.fake_entrypoint.dist.version = self.test_version
self.manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
self.manager.load()
def get_extension_manager():
global _extension_manager
if not _extension_manager:
_extension_manager = ExtensionManager("reviewboard.extensions")
return _extension_manager
def setUp(self):
manager = ExtensionManager('')
self.extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.extension_hook_class = TestExtensionHook
self.dummy_hook = Mock()
self.extension_hook_class.add_hook(self.dummy_hook)
def setUp(self):
manager = ExtensionManager('')
self.test_extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.patterns = patterns('',
(r'^url_hook_test/', include('djblets.extensions.test.urls')))
self.url_hook = URLHook(self.test_extension, self.patterns)
def setUp(self):
manager = ExtensionManager('')
self.extension = \
TestExtensionWithRegistration(extension_manager=manager)
for index in range(0, 5):
self.extension.hooks.add(Mock())
def setUp(self):
class TestExtension(Extension):
"""An empty, dummy extension for testing"""
pass
self.key = 'test_key'
self.extension_class = TestExtension
self.manager = ExtensionManager(self.key)
self.fake_entrypoint = Mock()
self.fake_entrypoint.load = Mock(return_value=self.extension_class)
self.fake_entrypoint.dist = Mock()
self.test_author = 'Test author lorem ipsum'
self.test_description = 'Test description lorem ipsum'
self.test_email = 'Test [email protected]'
self.test_home_page = 'http://www.example.com'
self.test_license = 'Test License MIT GPL Apache Drivers'
self.test_module_name = 'testextension.dummy.dummy'
self.test_module_to_app = 'testextension.dummy'
self.test_project_name = 'TestProjectName'
self.test_summary = 'Test summary lorem ipsum'
self.test_version = '1.0'
self.test_htdocs_path = os.path.join(settings.EXTENSIONS_STATIC_ROOT,
self.test_project_name)
self.test_metadata = {
'Name': self.test_project_name,
'Version': self.test_version,
'Summary': self.test_summary,
'Description': self.test_description,
'Author': self.test_author,
'Author-email': self.test_email,
'License': self.test_license,
'Home-page': self.test_home_page,
}
self.fake_entrypoint.dist.get_metadata_lines = Mock(
return_value=[
"%s: %s" % (key, value)
for key, value in self.test_metadata.iteritems()
])
self.fake_entrypoint.dist.project_name = self.test_project_name
self.fake_entrypoint.dist.version = self.test_version
self.manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
self.manager.load()
def setUp(self):
manager = ExtensionManager('')
self.extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.hook_with_applies_name = "template-hook-with-applies-name"
self.hook_no_applies_name = "template-hook-no-applies-name"
self.template_hook_no_applies = TemplateHook(self.extension,
self.hook_no_applies_name, "test_module/some_template.html", [])
self.template_hook_with_applies = TemplateHook(self.extension,
self.hook_with_applies_name, "test_module/some_template.html", [
'test-url-name',
'url_2',
'url_3',
]
)
self.fake_request = Mock()
self.fake_request._djblets_extensions_kwargs = {}
self.fake_request.path_info = '/'
self.context = {
'request': self.fake_request,
}
def test_extension_settings_sync(self):
"""Testing extension settings synchronization cross-process."""
key = "extension-settings-sync"
setting_key = "foo"
setting_val = "abc123"
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(return_value=[self.fake_entrypoint])
manager1.load()
extension1 = manager1.enable_extension(self.extension_class.id)
manager2.load()
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertNotEqual(extension2, None)
self.assertFalse(setting_key in extension1.settings)
self.assertFalse(setting_key in extension2.settings)
extension1.settings[setting_key] = setting_val
extension1.settings.save()
self.assertFalse(setting_key in extension2.settings)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
self.assertTrue(setting_key in extension1.settings)
self.assertTrue(setting_key in extension2.settings)
self.assertEqual(extension1.settings[setting_key], setting_val)
self.assertEqual(extension2.settings[setting_key], setting_val)
class ExtensionManagerTest(TestCase):
def setUp(self):
class TestExtension(Extension):
"""An empty, dummy extension for testing"""
pass
self.key = "test_key"
self.extension_class = TestExtension
self.manager = ExtensionManager(self.key)
self.fake_entrypoint = Mock()
self.fake_entrypoint.load = Mock(return_value=self.extension_class)
self.fake_entrypoint.dist = Mock()
self.test_author = "Test author lorem ipsum"
self.test_description = "Test description lorem ipsum"
self.test_email = "Test [email protected]"
self.test_home_page = "http://www.example.com"
self.test_license = "Test License MIT GPL Apache Drivers"
self.test_module_name = "testextension.dummy.dummy"
self.test_module_to_app = "testextension.dummy"
self.test_project_name = "TestProjectName"
self.test_summary = "Test summary lorem ipsum"
self.test_version = "1.0"
self.test_htdocs_path = os.path.join(settings.EXTENSIONS_STATIC_ROOT, self.test_project_name)
self.test_metadata = {
"Summary": self.test_summary,
"Description": self.test_description,
"Author": self.test_author,
"Author-email": self.test_email,
"License": self.test_license,
"Home-page": self.test_home_page,
}
self.fake_entrypoint.dist.get_metadata_lines = Mock(
return_value=["%s: %s" % (key, value) for key, value in self.test_metadata.iteritems()]
)
self.fake_entrypoint.dist.project_name = self.test_project_name
self.fake_entrypoint.dist.version = self.test_version
self.manager._entrypoint_iterator = Mock(return_value=[self.fake_entrypoint])
self.manager.load()
def tearDown(self):
self.manager.clear_sync_cache()
def test_added_to_extension_managers(self):
"""An ExtensionManager gets added to the _extension_managers list
in the djblets.extensions.base module."""
self.assertTrue(self.manager in _extension_managers)
def test_get_enabled_extensions_returns_empty(self):
"""An ExtensionManager should return an empty collection when asked
for the enabled extensions, if there are no extensions currently
enabled."""
self.assertEqual(len(self.manager.get_enabled_extensions()), 0)
def test_load(self):
"""An ExtensionManager should load any extensions that it finds
registered at entrypoints with its key. The loaded extension
should have an ExtensionRegistration and ExtensionInfo attached
to its class."""
self.assertEqual(len(self.manager.get_installed_extensions()), 1)
self.assertTrue(self.extension_class in self.manager.get_installed_extensions())
self.assertTrue(hasattr(self.extension_class, "info"))
self.assertEqual(self.extension_class.info.name, self.test_project_name)
self.assertTrue(hasattr(self.extension_class, "registration"))
self.assertEqual(self.extension_class.registration.name, self.test_project_name)
def test_load_full_reload_hooks(self):
"""Testing ExtensionManager.load(full_reload=True) with hook registration."""
self.assertEqual(len(self.manager.get_installed_extensions()), 1)
extension = self.extension_class()
extension = self.manager.enable_extension(self.extension_class.id)
URLHook(extension, ())
self.assertEqual(len(URLHook.hooks), 1)
self.assertEqual(URLHook.hooks[0].extension, extension)
self.manager.load(full_reload=True)
self.assertEqual(len(URLHook.hooks), 0)
def test_extension_list_sync(self):
"""Testing extension list synchronization cross-process."""
key = "extension-list-sync"
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(return_value=[self.fake_entrypoint])
manager1.load()
manager2.load()
self.assertEqual(len(manager1.get_installed_extensions()), 1)
self.assertEqual(len(manager2.get_installed_extensions()), 1)
self.assertEqual(len(manager1.get_enabled_extensions()), 0)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
manager1.enable_extension(self.extension_class.id)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 1)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
def test_extension_settings_sync(self):
"""Testing extension settings synchronization cross-process."""
key = "extension-settings-sync"
setting_key = "foo"
setting_val = "abc123"
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(return_value=[self.fake_entrypoint])
manager1.load()
extension1 = manager1.enable_extension(self.extension_class.id)
manager2.load()
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertNotEqual(extension2, None)
self.assertFalse(setting_key in extension1.settings)
self.assertFalse(setting_key in extension2.settings)
extension1.settings[setting_key] = setting_val
extension1.settings.save()
self.assertFalse(setting_key in extension2.settings)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
self.assertTrue(setting_key in extension1.settings)
self.assertTrue(setting_key in extension2.settings)
self.assertEqual(extension1.settings[setting_key], setting_val)
self.assertEqual(extension2.settings[setting_key], setting_val)
def test_extension_list_sync(self):
"""Testing extension list synchronization cross-process."""
key = "extension-list-sync"
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(return_value=[self.fake_entrypoint])
manager1.load()
manager2.load()
self.assertEqual(len(manager1.get_installed_extensions()), 1)
self.assertEqual(len(manager2.get_installed_extensions()), 1)
self.assertEqual(len(manager1.get_enabled_extensions()), 0)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
manager1.enable_extension(self.extension_class.id)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 1)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
class ExtensionManagerTest(TestCase):
def setUp(self):
class TestExtension(Extension):
"""An empty, dummy extension for testing"""
pass
self.key = 'test_key'
self.extension_class = TestExtension
self.manager = ExtensionManager(self.key)
self.fake_entrypoint = Mock()
self.fake_entrypoint.load = Mock(return_value=self.extension_class)
self.fake_entrypoint.dist = Mock()
self.test_author = 'Test author lorem ipsum'
self.test_description = 'Test description lorem ipsum'
self.test_email = 'Test [email protected]'
self.test_home_page = 'http://www.example.com'
self.test_license = 'Test License MIT GPL Apache Drivers'
self.test_module_name = 'testextension.dummy.dummy'
self.test_module_to_app = 'testextension.dummy'
self.test_project_name = 'TestProjectName'
self.test_summary = 'Test summary lorem ipsum'
self.test_version = '1.0'
self.test_htdocs_path = os.path.join(settings.EXTENSIONS_STATIC_ROOT,
self.test_project_name)
self.test_metadata = {
'Name': self.test_project_name,
'Version': self.test_version,
'Summary': self.test_summary,
'Description': self.test_description,
'Author': self.test_author,
'Author-email': self.test_email,
'License': self.test_license,
'Home-page': self.test_home_page,
}
self.fake_entrypoint.dist.get_metadata_lines = Mock(
return_value=[
"%s: %s" % (key, value)
for key, value in self.test_metadata.iteritems()
])
self.fake_entrypoint.dist.project_name = self.test_project_name
self.fake_entrypoint.dist.version = self.test_version
self.manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
self.manager.load()
def tearDown(self):
self.manager.clear_sync_cache()
def test_added_to_extension_managers(self):
"""Testing ExtensionManager registration"""
self.assertTrue(self.manager in _extension_managers)
def test_get_enabled_extensions_returns_empty(self):
"""Testing ExtensionManager.get_enabled_extensions with no extensions"""
self.assertEqual(len(self.manager.get_enabled_extensions()), 0)
def test_load(self):
"""Testing ExtensionManager.get_installed_extensions with loaded extensions"""
self.assertEqual(len(self.manager.get_installed_extensions()), 1)
self.assertTrue(self.extension_class in
self.manager.get_installed_extensions())
self.assertTrue(hasattr(self.extension_class, 'info'))
self.assertEqual(self.extension_class.info.name,
self.test_project_name)
self.assertTrue(hasattr(self.extension_class, 'registration'))
self.assertEqual(self.extension_class.registration.name,
self.test_project_name)
def test_load_full_reload_hooks(self):
"""Testing ExtensionManager.load with full_reload=True"""
self.assertEqual(len(self.manager.get_installed_extensions()), 1)
extension = self.extension_class(extension_manager=self.manager)
extension = self.manager.enable_extension(self.extension_class.id)
URLHook(extension, ())
self.assertEqual(len(URLHook.hooks), 1)
self.assertEqual(URLHook.hooks[0].extension, extension)
self.manager.load(full_reload=True)
self.assertEqual(len(URLHook.hooks), 0)
def test_extension_list_sync(self):
"""Testing ExtensionManager extension list synchronization cross-process."""
key = 'extension-list-sync'
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
manager1.load()
manager2.load()
self.assertEqual(len(manager1.get_installed_extensions()), 1)
self.assertEqual(len(manager2.get_installed_extensions()), 1)
self.assertEqual(len(manager1.get_enabled_extensions()), 0)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
manager1.enable_extension(self.extension_class.id)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 1)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
def test_extension_settings_sync(self):
"""Testing ExtensionManager extension settings synchronization cross-process."""
key = 'extension-settings-sync'
setting_key = 'foo'
setting_val = 'abc123'
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
manager1.load()
extension1 = manager1.enable_extension(self.extension_class.id)
manager2.load()
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertNotEqual(extension2, None)
self.assertFalse(setting_key in extension1.settings)
self.assertFalse(setting_key in extension2.settings)
extension1.settings[setting_key] = setting_val
extension1.settings.save()
self.assertFalse(setting_key in extension2.settings)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
self.assertTrue(setting_key in extension1.settings)
self.assertTrue(setting_key in extension2.settings)
self.assertEqual(extension1.settings[setting_key], setting_val)
self.assertEqual(extension2.settings[setting_key], setting_val)
class ExtensionManagerTest(TestCase):
def setUp(self):
class TestExtension(Extension):
"""An empty, dummy extension for testing"""
pass
self.key = 'test_key'
self.extension_class = TestExtension
self.manager = ExtensionManager(self.key)
self.fake_entrypoint = Mock()
self.fake_entrypoint.load = Mock(return_value=self.extension_class)
self.fake_entrypoint.dist = Mock()
self.test_author = 'Test author lorem ipsum'
self.test_description = 'Test description lorem ipsum'
self.test_email = 'Test [email protected]'
self.test_home_page = 'http://www.example.com'
self.test_license = 'Test License MIT GPL Apache Drivers'
self.test_module_name = 'testextension.dummy.dummy'
self.test_module_to_app = 'testextension.dummy'
self.test_project_name = 'TestProjectName'
self.test_summary = 'Test summary lorem ipsum'
self.test_version = '1.0'
self.test_htdocs_path = os.path.join(settings.EXTENSIONS_STATIC_ROOT,
self.test_project_name)
self.test_metadata = {
'Name': self.test_project_name,
'Version': self.test_version,
'Summary': self.test_summary,
'Description': self.test_description,
'Author': self.test_author,
'Author-email': self.test_email,
'License': self.test_license,
'Home-page': self.test_home_page,
}
self.fake_entrypoint.dist.get_metadata_lines = Mock(
return_value=[
"%s: %s" % (key, value)
for key, value in self.test_metadata.iteritems()
])
self.fake_entrypoint.dist.project_name = self.test_project_name
self.fake_entrypoint.dist.version = self.test_version
self.manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
self.manager.load()
def tearDown(self):
self.manager.clear_sync_cache()
def test_added_to_extension_managers(self):
"""Testing ExtensionManager registration"""
self.assertTrue(self.manager in _extension_managers)
def test_get_enabled_extensions_returns_empty(self):
"""Testing ExtensionManager.get_enabled_extensions with no extensions"""
self.assertEqual(len(self.manager.get_enabled_extensions()), 0)
def test_load(self):
"""Testing ExtensionManager.get_installed_extensions with loaded extensions"""
self.assertEqual(len(self.manager.get_installed_extensions()), 1)
self.assertTrue(self.extension_class in
self.manager.get_installed_extensions())
self.assertTrue(hasattr(self.extension_class, 'info'))
self.assertEqual(self.extension_class.info.name,
self.test_project_name)
self.assertTrue(hasattr(self.extension_class, 'registration'))
self.assertEqual(self.extension_class.registration.name,
self.test_project_name)
def test_load_full_reload_hooks(self):
"""Testing ExtensionManager.load with full_reload=True"""
self.assertEqual(len(self.manager.get_installed_extensions()), 1)
extension = self.extension_class(extension_manager=self.manager)
extension = self.manager.enable_extension(self.extension_class.id)
URLHook(extension, ())
self.assertEqual(len(URLHook.hooks), 1)
self.assertEqual(URLHook.hooks[0].extension, extension)
self.manager.load(full_reload=True)
self.assertEqual(len(URLHook.hooks), 0)
def test_extension_list_sync(self):
"""Testing ExtensionManager extension list synchronization cross-process."""
key = 'extension-list-sync'
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
manager1.load()
manager2.load()
self.assertEqual(len(manager1.get_installed_extensions()), 1)
self.assertEqual(len(manager2.get_installed_extensions()), 1)
self.assertEqual(len(manager1.get_enabled_extensions()), 0)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
manager1.enable_extension(self.extension_class.id)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 1)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
def test_extension_settings_sync(self):
"""Testing ExtensionManager extension settings synchronization cross-process."""
key = 'extension-settings-sync'
setting_key = 'foo'
setting_val = 'abc123'
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
manager1.load()
extension1 = manager1.enable_extension(self.extension_class.id)
manager2.load()
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertNotEqual(extension2, None)
self.assertFalse(setting_key in extension1.settings)
self.assertFalse(setting_key in extension2.settings)
extension1.settings[setting_key] = setting_val
extension1.settings.save()
self.assertFalse(setting_key in extension2.settings)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
self.assertTrue(setting_key in extension1.settings)
self.assertTrue(setting_key in extension2.settings)
self.assertEqual(extension1.settings[setting_key], setting_val)
self.assertEqual(extension2.settings[setting_key], setting_val)
def test_extension_list_sync(self):
"""Testing ExtensionManager extension list synchronization cross-process."""
key = 'extension-list-sync'
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
manager1.load()
manager2.load()
self.assertEqual(len(manager1.get_installed_extensions()), 1)
self.assertEqual(len(manager2.get_installed_extensions()), 1)
self.assertEqual(len(manager1.get_enabled_extensions()), 0)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
manager1.enable_extension(self.extension_class.id)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 0)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
self.assertEqual(len(manager1.get_enabled_extensions()), 1)
self.assertEqual(len(manager2.get_enabled_extensions()), 1)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
class ExtensionManagerTest(TestCase):
def setUp(self):
self.key = 'test_key'
self.extension_class = TestExtensionWithoutRegistration
self.extension_id = \
'djblets.extensions.tests.TestExtensionWithoutRegistration'
self.manager = ExtensionManager(self.key)
self.fake_entrypoint = Mock()
self.fake_entrypoint.load = Mock(return_value=self.extension_class)
self.fake_entrypoint.dist = Mock()
self.test_author = 'Test author lorem ipsum'
self.test_description = 'Test description lorem ipsum'
self.test_email = 'Test [email protected]'
self.test_home_page = 'http://www.example.com'
self.test_license = 'Test License MIT GPL Apache Drivers'
self.test_module_name = 'testextension.dummy.dummy'
self.test_module_to_app = 'testextension.dummy'
self.test_project_name = 'TestProjectName'
self.test_summary = 'Test summary lorem ipsum'
self.test_version = '1.0'
self.test_htdocs_path = os.path.join(settings.EXTENSIONS_STATIC_ROOT,
self.test_project_name)
self.test_metadata = {
'Summary': self.test_summary,
'Description': self.test_description,
'Author': self.test_author,
'Author-email': self.test_email,
'License': self.test_license,
'Home-page': self.test_home_page,
}
self.fake_entrypoint.dist.get_metadata_lines = Mock(
return_value=[
"%s: %s" % (key, value)
for key, value in self.test_metadata.iteritems()
])
self.fake_entrypoint.dist.project_name = self.test_project_name
self.fake_entrypoint.dist.version = self.test_version
self.manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
self.manager.load()
def test_added_to_extension_managers(self):
"""An ExtensionManager gets added to the _extension_managers list
in the djblets.extensions.base module."""
self.assertTrue(self.manager in _extension_managers)
def test_get_enabled_extensions_returns_empty(self):
"""An ExtensionManager should return an empty collection when asked
for the enabled extensions, if there are no extensions currently
enabled."""
self.assertTrue(len(self.manager.get_enabled_extensions()) == 0)
def test_load(self):
"""An ExtensionManager should load any extensions that it finds
registered at entrypoints with its key. The loaded extension
should have an ExtensionRegistration and ExtensionInfo attached
to its class."""
self.assertTrue(len(self.manager.get_installed_extensions()) == 1)
self.assertTrue(self.extension_class in
self.manager.get_installed_extensions())
self.assertTrue(hasattr(self.extension_class, 'info'))
self.assertEqual(self.extension_class.info.name,
self.test_project_name)
self.assertTrue(hasattr(self.extension_class, 'registration'))
self.assertEqual(self.extension_class.registration.name,
self.test_project_name)
def setUp(self):
manager = ExtensionManager('')
self.extension = DummyExtension(extension_manager=manager)
def setUp(self):
manager = ExtensionManager('')
self.extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.extension_hook = TestExtensionHook(self.extension)
def test_extension_settings_sync(self):
"""Testing ExtensionManager extension settings synchronization cross-process."""
key = 'extension-settings-sync'
setting_key = 'foo'
setting_val = 'abc123'
manager1 = ExtensionManager(key)
manager2 = ExtensionManager(key)
for manager in (manager1, manager2):
manager._entrypoint_iterator = Mock(
return_value=[self.fake_entrypoint]
)
manager1.load()
extension1 = manager1.enable_extension(self.extension_class.id)
manager2.load()
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertNotEqual(extension2, None)
self.assertFalse(setting_key in extension1.settings)
self.assertFalse(setting_key in extension2.settings)
extension1.settings[setting_key] = setting_val
extension1.settings.save()
self.assertFalse(setting_key in extension2.settings)
self.assertFalse(manager1.is_expired())
self.assertTrue(manager2.is_expired())
manager2.load(full_reload=True)
extension2 = manager2.get_enabled_extension(self.extension_class.id)
self.assertFalse(manager1.is_expired())
self.assertFalse(manager2.is_expired())
self.assertTrue(setting_key in extension1.settings)
self.assertTrue(setting_key in extension2.settings)
self.assertEqual(extension1.settings[setting_key], setting_val)
self.assertEqual(extension2.settings[setting_key], setting_val)
