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.assertItemsEqual(plugin_mgr.directories, [expected_plugins_path])
self.assertItemsEqual(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_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 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.assertItemsEqual(plugin_mgr.directories, [expected_plugins_path])
self.assertItemsEqual(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(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.assertItemsEqual(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_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.assertItemsEqual(plugin_mgr.directories, [expected_plugins_path])
self.assertItemsEqual(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 _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_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_interactive_environ_plugin_load(self):
"""
"""
mock_app_dir = galaxy_mock.MockDir({
'plugins': {
'ipython': {
'config': {
'ipython.xml': ipython_config
},
'templates': {
'ipython.mako': ipython_template
}
},
}
})
mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path)
plugin_mgr = VisualizationsRegistry(
mock_app,
directories_setting='plugins',
template_cache_dir=mock_app_dir.root_path)
# use a mock request factory - this will be written into the filled template to show it was used
plugin_mgr.IE_REQUEST_FACTORY = lambda t, p: 'mock_ie'
expected_plugins_path = os.path.join(mock_app_dir.root_path, 'plugins')
expected_plugin_names = ['ipython']
self.assertEqual(plugin_mgr.base_url, 'visualizations')
self.assertItemsEqual(plugin_mgr.directories, [expected_plugins_path])
self.assertItemsEqual(plugin_mgr.plugins.keys(), expected_plugin_names)
ipython_ie = plugin_mgr.plugins['ipython']
config = ipython_ie.get('config')
self.assertEqual(ipython_ie.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)
# should return the (new) api key for the above user (see the template above)
response = plugin_mgr.fill_template(trans, ipython_ie, 'ipython.mako')
response.strip()
self.assertIsInstance(response, basestring)
self.assertTrue('-' in response)
ie_request, api_key = response.split('-')
self.assertEqual(ie_request, 'mock_ie')
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_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 = test_utils.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_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_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.assertItemsEqual(plugin_mgr.directories, [expected_plugins_path])
self.assertEqual(plugin_mgr.plugins.keys(), [])
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.assertItemsEqual(plugin_mgr.directories, [expected_plugins_path])
self.assertEqual(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 = test_utils.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_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(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_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.assertItemsEqual(
plugin_mgr.directories,
[expected_plugins_rel_path, expected_plugins_abs_path])
self.assertItemsEqual(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 test_abs_path_search(self):
"""should be able to search given abs. path"""
mock_app_dir = galaxy_mock.MockDir({})
mock_plugin_dir = galaxy_mock.MockDir({
'plugin1': {},
'plugin2': {},
'file1': 'blerbler'
})
mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path)
plugin_mgr = PluginManager(
mock_app, directories_setting=mock_plugin_dir.root_path)
expected_plugins_path = mock_plugin_dir.root_path
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'))
def test_run_hooks( self ):
"""should run hooks of loaded plugins"""
mock_app_dir = galaxy_mock.MockDir({
'plugins': {
'plugin1': {
loading_point: contents5
},
'plugin2': {
loading_point: contents6
}
}
})
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' ] )
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_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'
},
},
'not_a_vis1': {
# no config
'static': {},
'templates': {},
},
# empty
'not_a_vis2': {},
'not_a_vis3': 'blerbler',
# bad config
'not_a_vis4': {
'config': {
'not_a_vis4.xml': 'blerbler'
}
},
}
})
mock_app = galaxy_mock.MockApp(root=mock_app_dir.root_path)
plugin_mgr = VisualizationsRegistry(mock_app,
directories_setting='plugins',
template_cache_dir='bler')
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.assertItemsEqual(plugin_mgr.directories, [expected_plugins_path])
self.assertItemsEqual(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()
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_interactive_environ_plugin_load( self ):
"""
"""
ipython_config = test_utils.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()
