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 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_environment_hook_options_no_plugins(self): # Given environment_manager = ExtensionManager.make_test_instance( [], 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) # When plugin_manager.add_plugin_arguments(parser) # Then actions = parser._actions self.assertEqual(len(actions), 0) # When args = parser.parse_args([]) enabled_plugins = plugin_manager.get_enabled_hook_plugins( plugin_manager.ENVIRONMENT_HOOK, args) # Then self.assertEqual(enabled_plugins, [])
def test_get_default_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([]) plugin_manager.get_driver(plugin_manager.TEST_RUNNER, args) runner = plugin_manager.get_driver(plugin_manager.TEST_RUNNER, args) # Then self.assertNotIsInstance(runner, OtherRunner)
def test_environment_hook_options(self): class TestingPlugin(BaseTestingPlugin): add_parser_arguments_called = 0 from_args_called = 0 @classmethod def add_parser_arguments(cls, parser, name, option_prefix, dest_prefix): cls.add_parser_arguments_called += 1 return super(TestingPlugin, cls).add_parser_arguments( parser, name, option_prefix, dest_prefix) @classmethod def from_args(cls, args, name, dest_prefix): cls.from_args_called += 1 return super(TestingPlugin, cls).from_args( args, name, dest_prefix) # 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) # When plugin_manager.add_plugin_arguments(parser) # Then self.assertEqual(TestingPlugin.add_parser_arguments_called, 1) actions = parser._actions self.assertEqual(len(actions), 1) action, = actions self.assertEqual(action.option_strings, ['--with-testing-plugin']) # When args = parser.parse_args([]) enabled_plugins = plugin_manager.get_enabled_hook_plugins( plugin_manager.ENVIRONMENT_HOOK, args) # Then self.assertEqual(enabled_plugins, []) self.assertEqual(TestingPlugin.from_args_called, 1) # When args = parser.parse_args(['--with-testing-plugin']) enabled_plugins = plugin_manager.get_enabled_hook_plugins( plugin_manager.ENVIRONMENT_HOOK, args) # Then self.assertEqual(len(enabled_plugins), 1) plugin_obj, = enabled_plugins self.assertEqual(TestingPlugin.from_args_called, 2) self.assertTrue(plugin_obj.enabled)
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 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 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_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 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 test_no_driver_hook_found(self): # Given driver_managers = [ (PluginManager.TEST_RUNNER, ExtensionManager.make_test_instance( [], 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), 0)
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 get_insert_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:' 'DummyInsert', DummyInsert(), None), ])
def test_no_driver_hook_found(self): # Given driver_managers = [ (PluginManager.TEST_RUNNER, ExtensionManager.make_test_instance( [], 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), 0)
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 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_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 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 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_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): # 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 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_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 test_environment_hook_options_no_plugins(self): # Given environment_manager = ExtensionManager.make_test_instance( [], 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) # When plugin_manager.add_plugin_arguments(parser) # Then actions = parser._actions self.assertEqual(len(actions), 0) # When args = parser.parse_args([]) enabled_plugins = plugin_manager.get_enabled_hook_plugins( plugin_manager.ENVIRONMENT_HOOK, args) # Then self.assertEqual(enabled_plugins, [])
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)
def test_environment_hook_options(self): class TestingPlugin(BaseTestingPlugin): add_parser_arguments_called = 0 from_args_called = 0 @classmethod def add_parser_arguments(cls, parser, name, option_prefix, dest_prefix): cls.add_parser_arguments_called += 1 return super(TestingPlugin, cls).add_parser_arguments(parser, name, option_prefix, dest_prefix) @classmethod def from_args(cls, args, name, dest_prefix): cls.from_args_called += 1 return super(TestingPlugin, cls).from_args(args, name, dest_prefix) # 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) # When plugin_manager.add_plugin_arguments(parser) # Then self.assertEqual(TestingPlugin.add_parser_arguments_called, 1) actions = parser._actions self.assertEqual(len(actions), 1) action, = actions self.assertEqual(action.option_strings, ['--with-testing-plugin']) # When args = parser.parse_args([]) enabled_plugins = plugin_manager.get_enabled_hook_plugins( plugin_manager.ENVIRONMENT_HOOK, args) # Then self.assertEqual(enabled_plugins, []) self.assertEqual(TestingPlugin.from_args_called, 1) # When args = parser.parse_args(['--with-testing-plugin']) enabled_plugins = plugin_manager.get_enabled_hook_plugins( plugin_manager.ENVIRONMENT_HOOK, args) # Then self.assertEqual(len(enabled_plugins), 1) plugin_obj, = enabled_plugins self.assertEqual(TestingPlugin.from_args_called, 2) self.assertTrue(plugin_obj.enabled)
def setUp(self): super(GroupAccessTestCase, self).setUp() 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)