def test_update(self):
"""
Test whether overriden update method changes modification date.
"""
meta = PluginMeta.objects.get(name=self.plugin_name)
initial_mod_date = meta.modification_date
data = {'name': self.plugin_name, 'public_repo': 'http://github.com/plugin'}
plg_meta_serializer = PluginMetaSerializer(meta, data)
plg_meta_serializer.is_valid(raise_exception=True)
meta = plg_meta_serializer.update(meta, plg_meta_serializer.validated_data)
self.assertGreater(meta.modification_date, initial_mod_date)
def test_validate_new_owner(self):
"""
Test whether overriden validate_new_owner method checks whether a new plugin
owner is a system-registered user.
"""
another_user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
plg_meta_serializer = PluginMetaSerializer()
with self.assertRaises(serializers.ValidationError):
plg_meta_serializer.validate_new_owner("unknown")
new_owner = plg_meta_serializer.validate_new_owner("another")
self.assertEqual(new_owner, another_user)
def _create_plugin(self, plg_repr, compute_resource):
"""
Private utility method to register/add a new plugin into the system.
"""
meta_data = {
'name': plg_repr.pop('name'),
'stars': plg_repr.pop('stars', 0),
'public_repo': plg_repr.pop('public_repo', ''),
'license': plg_repr.pop('license', ''),
'type': plg_repr.pop('type'),
'icon': plg_repr.pop('icon', ''),
'category': plg_repr.pop('category', ''),
'authors': plg_repr.pop('authors', '')
}
parameters_data = plg_repr.pop('parameters')
# check whether plugin_name does not exist and validate the plugin meta data
try:
meta = PluginMeta.objects.get(name=meta_data['name'])
meta_serializer = PluginMetaSerializer(meta, data=meta_data)
except PluginMeta.DoesNotExist:
meta_serializer = PluginMetaSerializer(data=meta_data)
meta_serializer.is_valid(raise_exception=True)
# validate the plugin's versioned data
plg_serializer = PluginSerializer(data=plg_repr)
plg_serializer.is_valid(raise_exception=True)
# collect and validate parameters
parameters_serializers = []
for parameter in parameters_data:
default = parameter.pop('default', None)
parameter_serializer = PluginParameterSerializer(data=parameter)
parameter_serializer.is_valid(raise_exception=True)
serializer_dict = {
'serializer': parameter_serializer,
'default_serializer': None
}
if default is not None:
param_type = parameter['type']
default_param_serializer = DEFAULT_PARAMETER_SERIALIZERS[
param_type](data={
'value': default
})
default_param_serializer.is_valid(raise_exception=True)
serializer_dict[
'default_serializer'] = default_param_serializer
parameters_serializers.append(serializer_dict)
# if no validation errors at this point then save to the DB
pl_meta = meta_serializer.save()
plugin = plg_serializer.save(meta=pl_meta,
compute_resources=[compute_resource])
for param_serializer_dict in parameters_serializers:
param = param_serializer_dict['serializer'].save(plugin=plugin)
if param_serializer_dict['default_serializer'] is not None:
param_serializer_dict['default_serializer'].save(
plugin_param=param)
return plugin
def modify_plugin(self, args):
"""
Modify an existing/registered plugin.
"""
try:
plugin_meta = PluginMeta.objects.get(name=args.name)
except PluginMeta.DoesNotExist:
raise NameError("Couldn't find plugin '%s' in the system" % args.name)
data = {'name': plugin_meta.name, 'public_repo': args.publicrepo}
plugin_meta_serializer = PluginMetaSerializer(plugin_meta, data=data)
plugin_meta_serializer.is_valid(raise_exception=True)
plugin_meta_serializer.save()