def test_rel_path_search(self): """should be able to search given rel. path""" mock_app_dir = galaxy_mock.MockDir( {'plugins': { 'plugin1': {}, 'plugin2': {}, 'file1': 'blerbler' }}) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = PluginManager(mock_app, directories_setting='plugins') app_path = mock_app_dir.root_path expected_plugins_path = os.path.join(app_path, 'plugins') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(sorted(plugin_mgr.plugins.keys()), ['plugin1', 'plugin2']) self.assertEqual(plugin_mgr.plugins['plugin1'].name, 'plugin1') self.assertEqual(plugin_mgr.plugins['plugin1'].path, os.path.join(expected_plugins_path, 'plugin1')) self.assertEqual(plugin_mgr.plugins['plugin2'].name, 'plugin2') self.assertEqual(plugin_mgr.plugins['plugin2'].path, os.path.join(expected_plugins_path, 'plugin2')) mock_app_dir.remove()
def test_plugin_templates(self): """""" mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'plugin1': { 'templates': { 'test.mako': contents1 }, } } }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = PageServingPluginManager(mock_app, 'test', directories_setting='plugins') self.assertEqual(list(plugin_mgr.plugins.keys()), ['plugin1']) plugin = plugin_mgr.plugins['plugin1'] rendered = plugin_mgr.fill_template(galaxy_mock.MockTrans(), plugin, 'test.mako', what='Hey', you='Ho', say='HeyHey HoHo') self.assertEqual(rendered, 'Hey Ho HeyHey HoHo') mock_app_dir.remove()
def test_init_with_context(self): """ A plugin with context passed in should use those in it's set up. """ vis_dir = galaxy_mock.MockDir({ 'config': { 'vis1.xml': '' }, 'static': {}, 'templates': {}, }) config = dict() context = dict(base_url='u/wot/m8', template_cache_dir='template_cache', additional_template_paths=['one']) plugin = self.plugin_class(galaxy_mock.MockApp(), vis_dir.root_path, 'myvis', config, context=context) self.assertEqual(plugin.base_url, 'u/wot/m8/myvis') # static self.assertEqual(plugin.static_url, 'u/wot/m8/myvis/static') # template self.assertEqual(plugin.template_lookup.__class__.__name__, 'TemplateLookup')
def test_default_init(self): """ A plugin with no context passed in should have sane defaults. """ vis_dir = galaxy_mock.MockDir({ 'config': { 'vis1.xml': '' }, 'static': {}, 'templates': {}, }) config = dict() plugin = self.plugin_class(galaxy_mock.MockApp(), vis_dir.root_path, 'myvis', config) self.assertEqual(plugin.name, 'myvis') self.assertEqual(plugin.path, vis_dir.root_path) self.assertEqual(plugin.config, {}) self.assertEqual(plugin.base_url, 'myvis') # static self.assertTrue(plugin.serves_static) self.assertEqual(plugin.static_path, vis_dir.root_path + '/static') self.assertEqual(plugin.static_url, 'myvis/static') # template self.assertTrue(plugin.serves_templates) self.assertEqual(plugin.template_path, vis_dir.root_path + '/templates') self.assertEqual(plugin.template_lookup.__class__.__name__, 'TemplateLookup') # resource parser self.assertIsInstance(plugin.resource_parser, resource_parser.ResourceParser)
def test_hook_errs(self): """should fail gracefully if hook fails (and continue with other plugins)""" mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'plugin1': { loading_point: contents5 }, 'plugin2': { loading_point: contents6 }, 'plugin3': { loading_point: contents7 } } }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = HookPluginManager(mock_app, directories_setting='plugins', skip_bad_plugins=False) self.assertEqual(sorted(plugin_mgr.plugins.keys()), ['plugin1', 'plugin2', 'plugin3']) return_val_dict = plugin_mgr.run_hook('blah', 'one two check') self.assertEqual(return_val_dict, { 'plugin1': 'One Two Check', 'plugin2': 'ONE TWO CHECK' }) result = plugin_mgr.filter_hook('filter_test', 'check') self.assertEqual(result, 'check one two') mock_app_dir.remove()
def test_loading_point(self): """should attempt load on dirs containing loading_point file""" mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'plugin1': { loading_point: contents1 }, 'not_a_plugin': 'blerbler' } }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = HookPluginManager(mock_app, directories_setting='plugins') app_path = mock_app_dir.root_path expected_plugins_path = os.path.join(app_path, 'plugins') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(list(plugin_mgr.plugins.keys()), ['plugin1']) plugin = plugin_mgr.plugins['plugin1'] self.assertEqual(plugin.name, 'plugin1') self.assertEqual(plugin.path, os.path.join(expected_plugins_path, 'plugin1')) self.assertIsInstance(plugin.module, types.ModuleType) self.assertEqual(plugin.module.bler(2), (2, 3)) mock_app_dir.remove()
def test_import_w_galaxy_import(self): """should allow loading_point to rel. import GALAXY modules""" mock_app_dir = galaxy_mock.MockDir( {'plugins': { 'plugin1': { loading_point: contents4 } }}) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = HookPluginManager(mock_app, directories_setting='plugins', skip_bad_plugins=False) app_path = mock_app_dir.root_path expected_plugins_path = os.path.join(app_path, 'plugins') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(list(plugin_mgr.plugins.keys()), ['plugin1']) plugin = plugin_mgr.plugins['plugin1'] self.assertEqual(plugin.name, 'plugin1') self.assertEqual(plugin.path, os.path.join(expected_plugins_path, 'plugin1')) self.assertIsInstance(plugin.module, types.ModuleType) self.assertEqual(plugin.module.blah('one,two'), ['one', 'two']) mock_app_dir.remove()
def test_multiple_dirs( self ): """should search in multiple directories""" mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'plugin1': {}, 'plugin2': {}, 'file1': 'blerbler' } }) mock_abs_plugin_dir = galaxy_mock.MockDir({ 'plugin3': {}, 'plugin4': {}, 'file2': 'blerbler' }) mock_app = galaxy_mock.MockApp( root=mock_app_dir.root_path ) directories_setting = ','.join([ 'plugins', mock_abs_plugin_dir.root_path ]) plugin_mgr = PluginManager( mock_app, directories_setting=directories_setting ) app_path = mock_app_dir.root_path expected_plugins_rel_path = os.path.join( app_path, 'plugins' ) expected_plugins_abs_path = mock_abs_plugin_dir.root_path self.assertEqual( sorted(plugin_mgr.directories), sorted([ expected_plugins_rel_path, expected_plugins_abs_path ]) ) self.assertEqual( sorted(plugin_mgr.plugins.keys()), [ 'plugin1', 'plugin2', 'plugin3', 'plugin4' ] ) self.assertEqual( plugin_mgr.plugins[ 'plugin1' ].name, 'plugin1' ) self.assertEqual( plugin_mgr.plugins[ 'plugin1' ].path, os.path.join( expected_plugins_rel_path, 'plugin1' ) ) self.assertEqual( plugin_mgr.plugins[ 'plugin2' ].name, 'plugin2' ) self.assertEqual( plugin_mgr.plugins[ 'plugin2' ].path, os.path.join( expected_plugins_rel_path, 'plugin2' ) ) self.assertEqual( plugin_mgr.plugins[ 'plugin3' ].name, 'plugin3' ) self.assertEqual( plugin_mgr.plugins[ 'plugin3' ].path, os.path.join( expected_plugins_abs_path, 'plugin3' ) ) self.assertEqual( plugin_mgr.plugins[ 'plugin4' ].name, 'plugin4' ) self.assertEqual( plugin_mgr.plugins[ 'plugin4' ].path, os.path.join( expected_plugins_abs_path, 'plugin4' ) )
def _new_trans(self, allowed_origin_hostnames=None): app = galaxy_mock.MockApp() app.config = CORSParsingMockConfig( allowed_origin_hostnames=allowed_origin_hostnames) webapp = galaxy_mock.MockWebapp() environ = galaxy_mock.buildMockEnviron() trans = StubGalaxyWebTransaction(environ, app, webapp) return trans
def test_plugin_load(self): """should attempt load if criteria met""" mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'plugin1': { 'templates': {}, 'static': {} }, 'plugin2': { 'static': {} }, 'plugin3': { 'templates': {} }, 'not_a_plugin1': 'blerbler', 'not_a_plugin2': {}, } }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = PageServingPluginManager(mock_app, 'test', directories_setting='plugins') app_path = mock_app_dir.root_path expected_plugins_path = os.path.join(app_path, 'plugins') self.assertEqual(plugin_mgr.base_url, 'test') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(sorted(plugin_mgr.plugins.keys()), ['plugin1', 'plugin2', 'plugin3']) plugin1 = plugin_mgr.plugins['plugin1'] self.assertEqual(plugin1.name, 'plugin1') self.assertEqual(plugin1.path, os.path.join(expected_plugins_path, 'plugin1')) self.assertEqual(plugin1.base_url, '/'.join([plugin_mgr.base_url, plugin1.name])) self.assertTrue(plugin1.serves_static) self.assertEqual(plugin1.static_path, os.path.join(plugin1.path, 'static')) self.assertEqual(plugin1.static_url, '/'.join([plugin1.base_url, 'static'])) self.assertTrue(plugin1.serves_templates) self.assertEqual(plugin1.template_path, os.path.join(plugin1.path, 'templates')) self.assertEqual(plugin1.template_lookup.__class__.__name__, 'TemplateLookup') plugin2 = plugin_mgr.plugins['plugin2'] self.assertEqual(plugin2.name, 'plugin2') self.assertEqual(plugin2.path, os.path.join(expected_plugins_path, 'plugin2')) self.assertEqual(plugin2.base_url, '/'.join([plugin_mgr.base_url, plugin2.name])) self.assertTrue(plugin2.serves_static) self.assertEqual(plugin2.static_path, os.path.join(plugin2.path, 'static')) self.assertEqual(plugin2.static_url, '/'.join([plugin2.base_url, 'static'])) self.assertFalse(plugin2.serves_templates) plugin3 = plugin_mgr.plugins['plugin3'] self.assertEqual(plugin3.name, 'plugin3') self.assertEqual(plugin3.path, os.path.join(expected_plugins_path, 'plugin3')) self.assertEqual(plugin3.base_url, '/'.join([plugin_mgr.base_url, plugin3.name])) self.assertFalse(plugin3.serves_static) self.assertTrue(plugin3.serves_templates) self.assertEqual(plugin1.template_path, os.path.join(plugin1.path, 'templates')) self.assertEqual(plugin1.template_lookup.__class__.__name__, 'TemplateLookup') mock_app_dir.remove()
def test_init_without_static_or_templates(self): """ A plugin that has neither template or static directory should serve neither. """ vis_dir = galaxy_mock.MockDir({'config': {'vis1.xml': ''}}) plugin = self.plugin_class(galaxy_mock.MockApp(), vis_dir.root_path, 'myvis', dict()) self.assertFalse(plugin.serves_static) self.assertFalse(plugin.serves_templates)
def test_build_config(self): """ """ plugin_config = dict() plugin = self.plugin_class(galaxy_mock.MockApp(), '', 'myvis', plugin_config) config = plugin._build_config({}) self.assertIsInstance(config, vis_utils.OpenObject) self.assertEqual(config.__dict__, {}) # existing should flow through plugin_config = dict() plugin = self.plugin_class(galaxy_mock.MockApp(), '', 'myvis', plugin_config) existing_config = dict(wat=1) config = plugin._build_config(existing_config) self.assertEqual(config.wat, 1) # unlisted/non-param kwargs should NOT overwrite existing plugin_config = dict() plugin = self.plugin_class(galaxy_mock.MockApp(), '', 'myvis', plugin_config) existing_config = dict(wat=1) config = plugin._build_config(existing_config, wat=2) self.assertEqual(config.wat, 1) # listed/param kwargs *should* overwrite existing plugin_config = dict(params=dict(wat={ 'csv': False, 'required': False, 'type': 'int', 'var_name_in_template': 'wot' }, )) plugin = self.plugin_class(galaxy_mock.MockApp(), '', 'myvis', plugin_config) existing_config = dict(wat=1) # send as string like a query would - should be parsed config = plugin._build_config(existing_config, wat='2') self.assertEqual(config.wat, 2)
def test_script_entry(self): """""" script_entry_config = utility.clean_multiline_string("""\ <?xml version="1.0" encoding="UTF-8"?> <visualization name="js-test"> <data_sources> <data_source> <model_class>HistoryDatasetAssociation</model_class> </data_source> </data_sources> <entry_point entry_point_type="script" data-main="one" src="bler"></entry_point> </visualization> """) mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'jstest': { 'config': { 'jstest.xml': script_entry_config }, 'static': {} }, } }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = VisualizationsRegistry( mock_app, directories_setting='plugins', template_cache_dir=template_cache_dir) script_entry = plugin_mgr.plugins['jstest'] self.assertIsInstance(script_entry, plugin.ScriptVisualizationPlugin) self.assertEqual(script_entry.name, 'jstest') self.assertTrue(script_entry.serves_static) self.assertTrue(script_entry.serves_templates) self.assertEqual(script_entry.static_path, os.path.join(script_entry.path, 'static')) trans = galaxy_mock.MockTrans() script_entry._set_up_template_plugin(mock_app_dir.root_path, [addtional_templates_dir]) response = script_entry._render({}, trans=trans, embedded=True) # print response self.assertTrue('src="bler"' in response) self.assertTrue('type="text/javascript"' in response) self.assertTrue('data-main="one"' in response) mock_app_dir.remove()
def test_bad_import(self): """should error gracefully (skip) on bad import""" mock_app_dir = galaxy_mock.MockDir( {'plugins': { 'plugin1': { loading_point: contents2 } }}) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = HookPluginManager(mock_app, directories_setting='plugins') app_path = mock_app_dir.root_path expected_plugins_path = os.path.join(app_path, 'plugins') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(list(plugin_mgr.plugins.keys()), []) mock_app_dir.remove()
def test_build_render_vars_default(self): """ Render vars passed to render should default properly. """ # well, that's kind of a lot of typing to say nothing new config = dict(name='Cat Fancy Magazine\'s Genomic Visualization') plugin = self.plugin_class(galaxy_mock.MockApp(), '', 'myvis', config) render_vars = plugin._build_render_vars(config) self.assertEqual(render_vars['visualization_name'], plugin.name) self.assertEqual(render_vars['visualization_display_name'], plugin.config['name']) self.assertEqual(render_vars['title'], None) self.assertEqual(render_vars['saved_visualization'], None) self.assertEqual(render_vars['visualization_id'], None) self.assertEqual(render_vars['query'], {}) self.assertIsInstance(render_vars['config'], vis_utils.OpenObject) self.assertEqual(render_vars['config'].__dict__, {})
def test_plugin_static_map(self): """""" mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'plugin1': { 'templates': {}, 'static': {} } } }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = PageServingPluginManager(mock_app, 'test', directories_setting='plugins') self.assertEqual(list(plugin_mgr.plugins.keys()), ['plugin1']) plugin = plugin_mgr.plugins['plugin1'] self.assertEqual(plugin_mgr.get_static_urls_and_paths(), [(plugin.static_url, plugin.static_path)]) mock_app_dir.remove()
def test_bad_loading_points(self): """should NOT attempt load on dirs NOT containing loading_point file""" mock_app_dir = galaxy_mock.MockDir( {'plugins': { 'plugin1': {}, 'plugin2': { 'plogin.py': 'wot' } }}) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = HookPluginManager(mock_app, directories_setting='plugins') app_path = mock_app_dir.root_path expected_plugins_path = os.path.join(app_path, 'plugins') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(list(plugin_mgr.plugins.keys()), []) mock_app_dir.remove()
def test_render(self): """ """ # use the python in a template to test for variables that should be there # TODO: gotta be a better way testing_template = utility.clean_multiline_string("""\ <% found_all = True should_have = [ title, visualization_name, visualization_display_name, visualization_id, saved_visualization, query, config, embedded, vars ] for var in should_have: try: var = str( var ) except NameError as name_err: found_all = False break %> ${ found_all } """) mock_app_dir = galaxy_mock.MockDir({ 'cache': {}, 'template.mako': testing_template }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin = self.plugin_class(mock_app, '', 'myvis', {"name": "Vlad News Bears"}) # somewhat easier to set this up by hand plugin.config['entry_point'] = {'file': 'template.mako'} plugin.template_path = mock_app_dir.root_path plugin.template_lookup = plugin._build_template_lookup( mock_app_dir.root_path) response = plugin.render(trans=galaxy_mock.MockTrans(app=mock_app)) self.assertIsInstance(response, string_types) self.assertEqual(response.strip(), "True")
def test_plugin_load_from_repo(self): """should attempt load if criteria met""" mock_app = galaxy_mock.MockApp(root=glx_dir) plugin_mgr = VisualizationsRegistry(mock_app, directories_setting=vis_reg_path, template_cache_dir=None) expected_plugins_path = os.path.join(glx_dir, vis_reg_path) self.assertEqual(plugin_mgr.base_url, 'visualizations') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) scatterplot = plugin_mgr.plugins['scatterplot'] self.assertEqual(scatterplot.name, 'scatterplot') self.assertEqual(scatterplot.path, os.path.join(expected_plugins_path, 'scatterplot')) self.assertEqual(scatterplot.base_url, '/'.join([plugin_mgr.base_url, scatterplot.name])) self.assertTrue(scatterplot.serves_static) self.assertEqual(scatterplot.static_path, os.path.join(scatterplot.path, 'static')) self.assertEqual(scatterplot.static_url, '/'.join([scatterplot.base_url, 'static'])) self.assertTrue(scatterplot.serves_templates) self.assertEqual(scatterplot.template_path, os.path.join(scatterplot.path, 'templates')) self.assertEqual(scatterplot.template_lookup.__class__.__name__, 'TemplateLookup') trackster = plugin_mgr.plugins['trackster'] self.assertEqual(trackster.name, 'trackster') self.assertEqual(trackster.path, os.path.join(expected_plugins_path, 'trackster')) self.assertEqual(trackster.base_url, '/'.join([plugin_mgr.base_url, trackster.name])) self.assertFalse(trackster.serves_static) self.assertFalse(trackster.serves_templates)
def setup_app(self): self.test_directory = tempfile.mkdtemp() self.app = galaxy_mock.MockApp() self.app.config.new_file_path = os.path.join(self.test_directory, "new_files") self.app.config.admin_users = "*****@*****.**"
def test_interactive_environ_plugin_load(self): """ """ ipython_config = utility.clean_multiline_string("""\ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE interactive_environment SYSTEM "../../interactive_environments.dtd"> <interactive_environment name="IPython"> <data_sources> <data_source> <model_class>HistoryDatasetAssociation</model_class> <test type="isinstance" test_attr="datatype" result_type="datatype">tabular.Tabular</test> <test type="isinstance" test_attr="datatype" result_type="datatype">data.Text</test> <to_param param_attr="id">dataset_id</to_param> </data_source> </data_sources> <params> <param type="dataset" var_name_in_template="hda" required="true">dataset_id</param> </params> <template>ipython.mako</template> </interactive_environment> """) mock_app_dir = { 'plugins': { 'ipython': { 'config': { 'ipython.xml': ipython_config }, 'templates': {} }, }, } # going to use a fake template here to simplify testing ipython_template = "${ ie_request }-${ get_api_key() }" mock_app_dir['plugins']['ipython']['templates'][ 'ipython.mako'] = ipython_template # so that we don't create a cached version of that fake template in the real mako caches # we'll set up a cache in the temp dir mock_app_dir['caches'] = {} # and make sure the vis reg uses that mock_app_dir = galaxy_mock.MockDir(mock_app_dir) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = VisualizationsRegistry(mock_app, directories_setting='plugins', template_cache_dir=os.path.join( mock_app_dir.root_path, 'caches')) # ...then start testing expected_plugins_path = os.path.join(mock_app_dir.root_path, 'plugins') expected_plugin_names = ['ipython'] self.assertEqual(plugin_mgr.base_url, 'visualizations') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(sorted(plugin_mgr.plugins.keys()), expected_plugin_names) ipython = plugin_mgr.plugins['ipython'] config = ipython.config self.assertEqual(ipython.name, 'ipython') self.assertEqual(config.get('plugin_type'), 'interactive_environment') # get_api_key needs a user, fill_template a trans user = model.User(email="*****@*****.**", password="******") trans = galaxy_mock.MockTrans(user=user) # use a mock request factory - this will be written into the filled template to show it was used ipython.INTENV_REQUEST_FACTORY = lambda t, p: 'mock' # should return the (new) api key for the above user (see the template above) response = ipython._render({}, trans=trans) response.strip() self.assertIsInstance(response, string_types) self.assertTrue('-' in response) ie_request, api_key = response.split('-') self.assertEqual(ie_request, 'mock') match = re.match(r'[a-f0-9]{32}', api_key) self.assertIsNotNone(match) self.assertEqual(match.span(), (0, 32)) mock_app_dir.remove()
def test_plugin_load(self): """""" mock_app_dir = galaxy_mock.MockDir({ 'plugins': { 'vis1': { 'config': { 'vis1.xml': config1 }, 'static': {}, 'templates': {}, }, 'vis2': { 'config': { 'vis2.xml': config1 } }, 'not_a_vis1': { 'config': { 'vis1.xml': 'blerbler' }, }, # empty 'not_a_vis2': {}, 'not_a_vis3': 'blerbler', # bad config 'not_a_vis4': { 'config': { 'not_a_vis4.xml': 'blerbler' } }, 'not_a_vis5': { # no config 'static': {}, 'templates': {}, }, } }) mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path) plugin_mgr = VisualizationsRegistry( mock_app, directories_setting='plugins', template_cache_dir=template_cache_dir) expected_plugins_path = os.path.join(mock_app_dir.root_path, 'plugins') expected_plugin_names = ['vis1', 'vis2'] self.assertEqual(plugin_mgr.base_url, 'visualizations') self.assertEqual(plugin_mgr.directories, [expected_plugins_path]) self.assertEqual(sorted(plugin_mgr.plugins.keys()), expected_plugin_names) vis1 = plugin_mgr.plugins['vis1'] self.assertEqual(vis1.name, 'vis1') self.assertEqual(vis1.path, os.path.join(expected_plugins_path, 'vis1')) self.assertEqual(vis1.base_url, '/'.join([plugin_mgr.base_url, vis1.name])) self.assertTrue(vis1.serves_static) self.assertEqual(vis1.static_path, os.path.join(vis1.path, 'static')) self.assertEqual(vis1.static_url, '/'.join([vis1.base_url, 'static'])) self.assertTrue(vis1.serves_templates) self.assertEqual(vis1.template_path, os.path.join(vis1.path, 'templates')) self.assertEqual(vis1.template_lookup.__class__.__name__, 'TemplateLookup') vis2 = plugin_mgr.plugins['vis2'] self.assertEqual(vis2.name, 'vis2') self.assertEqual(vis2.path, os.path.join(expected_plugins_path, 'vis2')) self.assertEqual(vis2.base_url, '/'.join([plugin_mgr.base_url, vis2.name])) self.assertFalse(vis2.serves_static) self.assertFalse(vis2.serves_templates) mock_app_dir.remove() template_cache_dir