def setUp(self):
super(PartitionTestCase, self).setUp()
# Set up two user partition schemes: mock and random
self.non_random_scheme = MockUserPartitionScheme(self.TEST_SCHEME_NAME)
self.random_scheme = MockUserPartitionScheme("random")
extensions = [
Extension(self.non_random_scheme.name,
USER_PARTITION_SCHEME_NAMESPACE, self.non_random_scheme,
None),
Extension(self.random_scheme.name, USER_PARTITION_SCHEME_NAMESPACE,
self.random_scheme, None),
]
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
extensions, namespace=USER_PARTITION_SCHEME_NAMESPACE)
# Create a test partition
self.user_partition = UserPartition(
self.TEST_ID,
self.TEST_NAME,
self.TEST_DESCRIPTION,
self.TEST_GROUPS,
extensions[0].plugin,
self.TEST_PARAMETERS,
)
# Make sure the names are set on the schemes (which happens normally in code, but may not happen in tests).
self.user_partition.get_scheme(self.non_random_scheme.name)
self.user_partition.get_scheme(self.random_scheme.name)
def test_hook_manager_should_return_named_extensions():
hook1 = Extension('captain', None, None, None)
hook2 = Extension('captain', None, None, None)
em = HookManager.make_test_instance([hook1, hook2])
assert [hook1, hook2] == em['captain']
def test_initialize_called(self):
driver1 = Extension('mock_driver1', Mock(), None,
Mock(native_bulk_support=True))
driver2 = Extension('mock_driver2', Mock(), None,
Mock(native_bulk_support=True))
manager = SfcDriverManager.make_test_instance([driver1, driver2])
manager.initialize()
driver1.obj.initialize.assert_called_once_with()
driver2.obj.initialize.assert_called_once_with()
def setUp(self):
super(TestUserPreferencesPluginBase, self).setUp()
self.extensions = []
self.extensions.append(
Extension('test_one', None, None, TestPreferencesPlugin(dict())))
self.extensions.append(
Extension('test_two', None, None,
TestOtherPreferencesPlugin(dict())))
def _test_method_called(self, method_name):
driver1 = Extension('mock_driver1', Mock(), None,
Mock(native_bulk_support=True))
driver2 = Extension('mock_driver2', Mock(), None,
Mock(native_bulk_support=True))
manager = SfcDriverManager.make_test_instance([driver1, driver2])
mocked_context = Mock()
getattr(manager, method_name)(mocked_context)
getattr(driver1.obj,
method_name).assert_called_once_with(mocked_context)
getattr(driver2.obj,
method_name).assert_called_once_with(mocked_context)
def _invoke_one(self, extension: Extension, objects: dict):
if extension.obj is not None:
return
extension.builtin = extension.name in dao.builtins
if extension.plugin in objects:
extension.obj = objects[extension.plugin]
else:
try:
extension.obj = extension.plugin()
objects[extension.plugin] = extension.obj
if extension.name not in self._disabled_plugins:
self._logger.info("Loaded Plugin '%s'", extension.name)
except Exception as exc:
self._on_load_fail(None, extension, exc)
def get_setter_cmpt_mgr():
return ExtensionManager.make_test_instance([
Extension(
'set_aggregated_metric_name',
'monasca_transform.component.setter.'
'set_aggregated_metric_name:SetAggregatedMetricName',
SetAggregatedMetricName(), None),
Extension(
'set_aggregated_period', 'monasca_transform.component.setter.'
'set_aggregated_period:SetAggregatedPeriod',
SetAggregatedPeriod(), None),
Extension(
'rollup_quantity', 'monasca_transform.component.setter.'
'rollup_quantity:RollupQuantity', RollupQuantity(), None)
])
def get_insert_pre_hourly_cmpt_mgr():
return ExtensionManager.make_test_instance([
Extension(
'prepare_data',
'monasca_transform.component.insert.prepare_data:PrepareData',
PrepareData(), None),
Extension(
'insert_data',
'tests.functional.component.insert.dummy_insert:'
'DummyInsert', DummyInsert(), None),
Extension(
'insert_data_pre_hourly', 'tests.functional.component.insert.'
'dummy_insert_pre_hourly:'
'DummyInsertPreHourly', DummyInsertPreHourly(), None),
])
def get_usage_cmpt_mgr():
return ExtensionManager.make_test_instance([
Extension(
'fetch_quantity', 'monasca_transform.component.usage.'
'fetch_quantity:'
'FetchQuantity', FetchQuantity(), None),
Extension(
'fetch_quantity_util', 'monasca_transform.component.usage.'
'fetch_quantity_util:'
'FetchQuantityUtil', FetchQuantityUtil(), None),
Extension(
'calculate_rate', 'monasca_transform.component.usage.'
'calculate_rate:'
'CalculateRate', CalculateRate(), None),
])
def _mk_extension(name, cls):
return Extension(
name,
Mock(name='entry_point_{}'.format(name)),
cls,
Mock(name='obj_{}'.format(name)),
)
def setUp(self):
# Set up two user partition schemes: mock and random
extensions = [
Extension(self.TEST_SCHEME_NAME, USER_PARTITION_SCHEME_NAMESPACE,
MockUserPartitionScheme(self.TEST_SCHEME_NAME), None),
Extension("random", USER_PARTITION_SCHEME_NAMESPACE,
MockUserPartitionScheme("random"), None),
]
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
extensions, namespace=USER_PARTITION_SCHEME_NAMESPACE)
# Create a test partition
self.user_partition = UserPartition(self.TEST_ID, self.TEST_NAME,
self.TEST_DESCRIPTION,
self.TEST_GROUPS,
extensions[0].plugin)
def test_add_new(self):
"""Add a new plugin to the scheduler."""
CONF.set_override('enable', True, 'scheduler')
self.assertIsNone(scheduler.SCHEDULER)
scheduler.initialize_scheduler()
mock_plugin = MockPlugin(dict())
mock_plugin_name = mock_plugin.get_name()
mock_extensions = [
Extension(mock_plugin_name, None, None, mock_plugin)
]
loader = StoryboardPluginLoader.make_test_instance(
mock_extensions, namespace='storyboard.plugin.testing'
)
test_list = list()
loader.map(scheduler.add_plugins, test_list)
self.assertTrue(test_list.index(mock_plugin_name) == 0)
self.assertIsNotNone(scheduler.SCHEDULER.get_job(mock_plugin_name))
scheduler.shutdown_scheduler()
self.assertIsNone(scheduler.SCHEDULER)
CONF.clear_override('enable', 'scheduler')
def setUp(self):
self.mgr = cmds.CommandManager()
self.mgr.load_namespace('contrail_api_cli.shell_command')
ep = EntryPoint('cmd', 'contrail_api_cli.tests.test_command', attrs=('Cmd',))
cls = ep.load(require=False)
ext = Extension('cmd', ep, cls, cls('cmd'))
self.mgr.mgrs[0].extensions.append(ext)
def get_hook_manager(*hooks):
hooks = hooks or [AddHook]
group = 'hook_point:foo'
ext = [
Extension('designate_hook', 'foo', hook, hook(group)) for hook in hooks
]
return HookManager.make_test_instance(ext, 'designate_hook')
def setUp(self):
super(TestPluginBase, self).setUp()
self.extensions = []
self.extensions.append(Extension(
'test_one', None, None,
TestBasePlugin(dict())
))
def _load_one_plugin(self, ep, invoke_on_load, invoke_args, invoke_kwds, verify_requirements=True):
if not ep.dist:
plugin = ep.load(require=False)
else:
plugin = ep.load(require=verify_requirements)
if invoke_on_load:
obj = plugin(*invoke_args, **invoke_kwds)
else:
obj = None
return Extension(ep.name, ep, plugin, obj)
def _test_method_exception(self,
method_name,
expected_exc=fc_exc.FlowClassifierDriverError):
driver = Extension('mock_driver', Mock(), None,
Mock(native_bulk_support=True))
mock_method = Mock(side_effect=fc_exc.FlowClassifierException)
setattr(driver.obj, method_name, mock_method)
manager = FlowClassifierDriverManager.make_test_instance([driver])
mocked_context = Mock()
self.assertRaises(expected_exc, getattr(manager, method_name),
mocked_context)
def wrapper(*args):
with patch('haas.haas_application.ResultCollector') as result_cls:
with patch('haas.plugins.runner.BaseTestRunner') as runner_class:
environment_manager = ExtensionManager.make_test_instance(
[],
namespace=PluginManager.ENVIRONMENT_HOOK,
)
result_handler = Extension('default', None, result_cls, None)
env_managers = [
(PluginManager.ENVIRONMENT_HOOK, environment_manager),
(
PluginManager.RESULT_HANDLERS,
ExtensionManager.make_test_instance(
[result_handler],
namespace=PluginManager.RESULT_HANDLERS),
),
]
runner = Extension('default', None, runner_class, None)
discoverer = Extension('default', None, Discoverer, None)
driver_managers = [
(
PluginManager.TEST_DISCOVERY,
ExtensionManager.make_test_instance(
[discoverer],
namespace=PluginManager.TEST_DISCOVERY),
),
(
PluginManager.TEST_RUNNER,
ExtensionManager.make_test_instance(
[runner], namespace=PluginManager.TEST_RUNNER),
),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=env_managers,
driver_managers=driver_managers)
args_ = args + (
runner_class,
result_cls,
plugin_manager,
)
return fn(*args_)
def setUp(self):
super(TestDriverLoader, self).setUp()
# To load the drivers without using the config file
self.useFixture(ConfFixture())
def _fake_parse(self, *args, **kw):
return cfg.ConfigOpts._parse_cli_opts(cfg.CONF, [])
cfg.CONF._parse_cli_opts = _fake_parse
# First dependency to be returned
self.no_group_driver_manager = DriverManager.make_test_instance(
extension=Extension(
name=FakeDriverNoGroup.get_name(),
entry_point="%s:%s" %
(FakeDriverNoGroup.__module__, FakeDriverNoGroup.__name__),
plugin=FakeDriverNoGroup,
obj=None,
),
namespace=FakeDriverNoGroup.namespace(),
)
# 2nd dependency to be returned
self.with_ext_opts_driver_manager = DriverManager.make_test_instance(
extension=Extension(
name=FakeDriverWithExternalOpts.get_name(),
entry_point="%s:%s" % (FakeDriverWithExternalOpts.__module__,
FakeDriverWithExternalOpts.__name__),
plugin=FakeDriverWithExternalOpts,
obj=None,
),
namespace=FakeDriverWithExternalOpts.namespace(),
)
self.patches.extend([
# patch.object(cfg, "ConfigOpts", ),
])
# Applies all of our patches before each test
for _patch in self.patches:
_patch.start()
def setUp(self):
config = MpTcpAnalyzerConfig()
self.m = MpTcpAnalyzer(config)
plugins = [
#name , entry point, plugin, obj
Extension("hello", 'mptcpanalyzer.command_example:', None,
mp.command_example.CommandExample())
]
mgr = self.m.cmd_mgr.make_test_instance(plugins)
self.m.load_plugins(mgr)
def test_get_other_driver(self):
# Given
class OtherRunner(BaseTestRunner):
pass
default = Extension('default', None, BaseTestRunner, None)
other = Extension('other', None, OtherRunner, None)
driver_managers = [
(PluginManager.TEST_RUNNER,
ExtensionManager.make_test_instance(
[default, other], namespace=PluginManager.TEST_RUNNER)),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=(), driver_managers=driver_managers)
parser = create_argument_parser()
plugin_manager.add_plugin_arguments(parser)
# When
args = parser.parse_args(['--runner', 'other'])
runner = plugin_manager.get_driver(plugin_manager.TEST_RUNNER, args)
# Then
self.assertIsInstance(runner, OtherRunner)
def test_load_driver_no_opt(self, m_driver_manager):
m_driver_manager.return_value = DriverManager.make_test_instance(
extension=Extension(
name=FakeLoadable.get_name(),
entry_point="%s:%s" %
(FakeLoadable.__module__, FakeLoadable.__name__),
plugin=FakeLoadable,
obj=None),
namespace=FakeLoadable.namespace())
loader_manager = DefaultLoader(namespace='TESTING')
loaded_driver = loader_manager.load(name='fake')
self.assertEqual(loaded_driver.get_name(), FakeLoadable.get_name())
def setUp(self):
super(PartitionTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
# Set up two user partition schemes: mock and random
self.non_random_scheme = MockUserPartitionScheme(self.TEST_SCHEME_NAME)
self.random_scheme = MockUserPartitionScheme("random")
self.enrollment_track_scheme = MockEnrollmentTrackUserPartitionScheme(self.ENROLLMENT_TRACK_SCHEME_NAME)
extensions = [
Extension(
self.non_random_scheme.name, USER_PARTITION_SCHEME_NAMESPACE, self.non_random_scheme, None
),
Extension(
self.random_scheme.name, USER_PARTITION_SCHEME_NAMESPACE, self.random_scheme, None
),
Extension(
self.enrollment_track_scheme.name, USER_PARTITION_SCHEME_NAMESPACE, self.enrollment_track_scheme, None
),
]
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
extensions, namespace=USER_PARTITION_SCHEME_NAMESPACE
)
# Be sure to clean up the global scheme_extensions after the test.
self.addCleanup(self.cleanup_scheme_extensions)
# Create a test partition
self.user_partition = UserPartition(
self.TEST_ID,
self.TEST_NAME,
self.TEST_DESCRIPTION,
self.TEST_GROUPS,
extensions[0].plugin,
self.TEST_PARAMETERS,
)
# Make sure the names are set on the schemes (which happens normally in code, but may not happen in tests).
self.user_partition.get_scheme(self.non_random_scheme.name)
self.user_partition.get_scheme(self.random_scheme.name)
def test_load_driver_no_opt(self, m_driver_manager):
m_driver_manager.return_value = DriverManager.make_test_instance(
extension=Extension(
name=FakeDriverNoOpt.get_name(),
entry_point="%s:%s" %
(FakeDriverNoOpt.__module__, FakeDriverNoOpt.__name__),
plugin=FakeDriverNoOpt,
obj=None,
),
namespace=FakeDriverNoOpt.namespace(),
)
loader_manager = DriverLoader(conf=cfg.CONF,
namespace='TESTING',
name='fake_no_opt')
loaded_driver = loader_manager.load()
self.assertEqual(isinstance(loaded_driver, FakeDriverNoOpt), True)
def test_add_plugins_reschedule(self):
"""Assert that the test_add_plugins will reschedule existing plugins.
"""
CONF.set_override('enable', True, 'scheduler')
self.assertIsNone(scheduler.SCHEDULER)
scheduler.initialize_scheduler()
mock_plugin = MockPlugin(dict())
mock_plugin_name = mock_plugin.get_name()
mock_extensions = [
Extension(mock_plugin_name, None, None, mock_plugin)
]
loader = StoryboardPluginLoader.make_test_instance(
mock_extensions, namespace='storyboard.plugin.testing'
)
test_list = list()
loader.map(scheduler.add_plugins, test_list)
self.assertTrue(test_list.index(mock_plugin_name) == 0)
first_run_job = scheduler.SCHEDULER.get_job(mock_plugin_name)
first_run_trigger = first_run_job.trigger
self.assertEqual(mock_plugin._trigger.run_date,
first_run_trigger.run_date)
# Update the plugin's interval and re-run
new_date = datetime.datetime.now() + datetime.timedelta(days=2)
mock_plugin._trigger = DateTrigger(run_date=new_date)
test_list = list()
loader.map(scheduler.add_plugins, test_list)
# make sure the plugin is only loaded once.
self.assertTrue(test_list.index(mock_plugin_name) == 0)
self.assertEquals(len(test_list), 1)
# Get the job.
second_run_job = scheduler.SCHEDULER.get_job(mock_plugin_name)
second_run_trigger = second_run_job.trigger
self.assertNotEqual(second_run_trigger.run_date,
first_run_trigger.run_date)
scheduler.shutdown_scheduler()
self.assertIsNone(scheduler.SCHEDULER)
CONF.clear_override('enable', 'scheduler')
def test_load_driver_with_opts(self, m_driver_manager):
m_driver_manager.return_value = DriverManager.make_test_instance(
extension=Extension(
name=FakeDriverWithOpts.get_name(),
entry_point="%s:%s" %
(FakeDriverWithOpts.__module__, FakeDriverWithOpts.__name__),
plugin=FakeDriverWithOpts,
obj=None,
),
namespace=FakeDriverWithOpts.namespace(),
)
loader_manager = DriverLoader(conf=cfg.CONF,
namespace='TESTING',
name='fake_with_opts')
loaded_driver = loader_manager.load()
self.assertEqual(hasattr(loaded_driver, "test_opt"), True)
self.assertEqual(loaded_driver.test_opt, "fake_with_opts")
def _load_one_plugin(self,
ep,
invoke_on_load,
invoke_args,
invoke_kwds,
verify_requirements=True):
if not ep.dist:
if hasattr(ep, '_load'):
plugin = ep._load(
) # `require` argument of ep.load() is deprecated in newer versions of setuptools
else:
plugin = ep.load(require=False)
else:
plugin = ep.load()
if invoke_on_load:
obj = plugin(*invoke_args, **invoke_kwds)
else:
obj = None
return Extension(ep.name, ep, plugin, obj)
def test_driver_hooks_found(self):
# Given
extension = Extension('haas.runner', None, BaseTestRunner, None)
driver_managers = [
(PluginManager.TEST_RUNNER,
ExtensionManager.make_test_instance(
[extension], namespace=PluginManager.TEST_RUNNER)),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=(), driver_managers=driver_managers)
parser = ArgumentParser(add_help=False)
# When
plugin_manager.add_plugin_arguments(parser)
# Then
actions = parser._actions
self.assertEqual(len(actions), 1)
action, = actions
self.assertEqual(action.option_strings, ['--runner'])
def test_hook_plugin_none(self):
class TestingPlugin(BaseTestingPlugin):
@classmethod
def from_args(cls, args, name, dest_prefix):
return None
# Given
extension = Extension('testing-plugin', None, TestingPlugin, None)
environment_manager = ExtensionManager.make_test_instance(
[extension],
namespace=PluginManager.ENVIRONMENT_HOOK,
)
hook_managers = [(PluginManager.ENVIRONMENT_HOOK, environment_manager)]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=hook_managers, driver_managers=())
parser = ArgumentParser(add_help=False)
args = parser.parse_args([])
# When
plugin = plugin_manager._create_hook_plugin(extension, args)
# Then
self.assertIsNone(plugin)
def setUp(self):
super(GroupAccessTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
[
Extension("memory", USER_PARTITION_SCHEME_NAMESPACE,
MemoryUserPartitionScheme(), None),
Extension("random", USER_PARTITION_SCHEME_NAMESPACE,
MemoryUserPartitionScheme(), None)
],
namespace=USER_PARTITION_SCHEME_NAMESPACE)
self.cat_group = Group(10, 'cats')
self.dog_group = Group(20, 'dogs')
self.worm_group = Group(30, 'worms')
self.animal_partition = UserPartition(
0,
'Pet Partition',
'which animal are you?',
[self.cat_group, self.dog_group, self.worm_group],
scheme=UserPartition.get_scheme("memory"),
)
self.red_group = Group(1000, 'red')
self.blue_group = Group(2000, 'blue')
self.gray_group = Group(3000, 'gray')
self.color_partition = UserPartition(
100,
'Color Partition',
'what color are you?',
[self.red_group, self.blue_group, self.gray_group],
scheme=UserPartition.get_scheme("memory"),
)
self.course = CourseFactory.create(
user_partitions=[self.animal_partition, self.color_partition], )
with self.store.bulk_operations(self.course.id, emit_signals=False):
chapter = ItemFactory.create(category='chapter',
parent=self.course)
section = ItemFactory.create(category='sequential', parent=chapter)
vertical = ItemFactory.create(category='vertical', parent=section)
component = ItemFactory.create(category='problem', parent=vertical)
self.chapter_location = chapter.location
self.section_location = section.location
self.vertical_location = vertical.location
self.component_location = component.location
self.red_cat = UserFactory() # student in red and cat groups
self.set_user_group(self.red_cat, self.animal_partition,
self.cat_group)
self.set_user_group(self.red_cat, self.color_partition, self.red_group)
self.blue_dog = UserFactory() # student in blue and dog groups
self.set_user_group(self.blue_dog, self.animal_partition,
self.dog_group)
self.set_user_group(self.blue_dog, self.color_partition,
self.blue_group)
self.white_mouse = UserFactory() # student in no group
self.gray_worm = UserFactory() # student in deleted group
self.set_user_group(self.gray_worm, self.animal_partition,
self.worm_group)
self.set_user_group(self.gray_worm, self.color_partition,
self.gray_group)
# delete the gray/worm groups from the partitions now so we can test scenarios
# for user whose group is missing.
self.animal_partition.groups.pop()
self.color_partition.groups.pop()
# add a staff user, whose access will be unconditional in spite of group access.
self.staff = StaffFactory.create(course_key=self.course.id)
