def method_display(self,minion=None,module=None,method=None):
global global_form
fc = Overlord(minion)
method_args = getattr(fc,module).get_method_args()
if not method_args.values():
print "Not registered method here"
return dict(minion_form = None,minion=minion,module=module,method=method)
minion_arguments = method_args[minion][method]['args']
if minion_arguments:
wlist_object = WidgetListFactory(minion_arguments,minion=minion,module=module,method=method)
wlist_object = wlist_object.get_widgetlist_object()
#create the validation parts for the remote form
wf = WidgetSchemaFactory(minion_arguments)
schema_man=wf.get_ready_schema()
#create the final form
minion_form = RemoteFormAutomation(wlist_object,schema_man)
global_form = minion_form.for_widget
#print global_form
#i use that when something goes wrong to check the problem better to stay here ;)
#self.minion_form =RemoteFormFactory(wlist_object,schema_man).get_remote_form()
del wlist_object
del minion_arguments
return dict(minion_form =minion_form,minion=minion,module=module,method=method)
else:
return dict(minion_form = None,minion=minion,module=module,method=method)
def remote_widget_render(self):
print "\n******testing minion : %s**********"%(self.minion)
fc = Overlord(self.minion)
modules = fc.system.list_modules()
display_modules={}
print "Getting the modules that has exported arguments"
for module in modules.itervalues():
for mod in module:
#if it is not empty
exported_methods = getattr(fc,mod).get_method_args()[self.minion]
if exported_methods:
print "%s will be rendered"%(mod)
display_modules[mod]=exported_methods
#do the rendering work here
for module,exp_meths in display_modules.iteritems():
for method_name,other_options in exp_meths.iteritems():
minion_arguments = other_options['args']
if minion_arguments:
wlist_object = WidgetListFactory(minion_arguments,minion=self.minion,module=module,method=method_name)
wlist_object = wlist_object.get_widgetlist_object()
#print wlist_object
wf = WidgetSchemaFactory(minion_arguments)
schema_man=wf.get_ready_schema()
minion_form = RemoteFormAutomation(wlist_object,schema_man)
print "%s.%s.%s rendered"%(self.minion,module,method_name)
def remote_widget_render(self):
print "\n******testing minion : %s**********" % (self.minion)
fc = Overlord(self.minion)
modules = fc.system.list_modules()
display_modules = {}
print "Getting the modules that has exported arguments"
for module in modules.itervalues():
for mod in module:
#if it is not empty
exported_methods = getattr(fc,
mod).get_method_args()[self.minion]
if exported_methods:
print "%s will be rendered" % (mod)
display_modules[mod] = exported_methods
#do the rendering work here
for module, exp_meths in display_modules.iteritems():
for method_name, other_options in exp_meths.iteritems():
minion_arguments = other_options['args']
if minion_arguments:
wlist_object = WidgetListFactory(minion_arguments,
minion=self.minion,
module=module,
method=method_name)
wlist_object = wlist_object.get_widgetlist_object()
#print wlist_object
wf = WidgetSchemaFactory(minion_arguments)
schema_man = wf.get_ready_schema()
minion_form = RemoteFormAutomation(wlist_object,
schema_man)
print "%s.%s.%s rendered" % (self.minion, module,
method_name)
def method_display(self, minion=None, module=None, method=None):
"""
That method generates the input widget for givent method.
"""
global global_form
if self.func_cache["minion_name"] == minion:
fc = self.func_cache["fc_object"]
else:
fc = Overlord(minion)
self.func_cache["fc_object"] = fc
self.func_cache["minion_name"] = minion
# reset the children :)
self.func_cache["module_name"] = module
self.func_cache["modules"] = None
self.func_cache["methods"] = None
# get the method args
method_args = getattr(fc, module).get_method_args()
if not method_args.values():
# print "Not registered method here"
return dict(minion_form=None, minion=minion, module=module, method=method)
minion_arguments = method_args[minion][method]["args"]
# the description of the method we are going to display
if method_args[minion][method].has_key("description"):
description = method_args[minion][method]["description"]
else:
description = None
if minion_arguments:
wlist_object = WidgetListFactory(minion_arguments, minion=minion, module=module, method=method)
wlist_object = wlist_object.get_widgetlist_object()
# create the validation parts for the remote form
wf = WidgetSchemaFactory(minion_arguments)
schema_man = wf.get_ready_schema()
# create the final form
minion_form = RemoteFormAutomation(wlist_object, schema_man)
global_form = minion_form.for_widget
# print global_form
# i use that when something goes wrong to check the problem better to stay here ;)
# self.minion_form =RemoteFormFactory(wlist_object,schema_man).get_remote_form()
del wlist_object
del minion_arguments
return dict(minion_form=minion_form, minion=minion, module=module, method=method, description=description)
else:
return dict(minion_form=None, minion=minion, module=module, method=method, description=description)
def method_display(self, minion=None, module=None, method=None):
"""
That method generates the input widget for givent method.
"""
global global_form
if self.func_cache['minion_name'] == minion:
fc = self.func_cache['fc_object']
else:
fc = Overlord(minion)
self.func_cache['fc_object'] = fc
self.func_cache['minion_name'] = minion
#reset the children :)
self.func_cache['module_name'] = module
self.func_cache['modules'] = None
self.func_cache['methods'] = None
#get the method args
method_args = getattr(fc, module).get_method_args()
if not method_args.values():
#print "Not registered method here"
return dict(minion_form=None,
minion=minion,
module=module,
method=method)
minion_arguments = method_args[minion][method]['args']
#the description of the method we are going to display
if method_args[minion][method].has_key('description'):
description = method_args[minion][method]['description']
else:
description = None
if minion_arguments:
wlist_object = WidgetListFactory(minion_arguments,
minion=minion,
module=module,
method=method)
wlist_object = wlist_object.get_widgetlist_object()
#create the validation parts for the remote form
wf = WidgetSchemaFactory(minion_arguments)
schema_man = wf.get_ready_schema()
#create the final form
minion_form = RemoteFormAutomation(wlist_object, schema_man)
global_form = minion_form.for_widget
#print global_form
#i use that when something goes wrong to check the problem better to stay here ;)
#self.minion_form =RemoteFormFactory(wlist_object,schema_man).get_remote_form()
del wlist_object
del minion_arguments
return dict(minion_form=minion_form,
minion=minion,
module=module,
method=method,
description=description)
else:
return dict(minion_form=None,
minion=minion,
module=module,
method=method,
description=description)
def setUp(self):
self.widget_factory = WidgetListFactory(self.get_test_default_args(),minion="myminion",module="mymodule",method="my_method")
class TestWidgetListFactory(unittest.TestCase):
def setUp(self):
self.widget_factory = WidgetListFactory(self.get_test_default_args(),minion="myminion",module="mymodule",method="my_method")
def tearDown(self):
pass
def test_default_args(self):
compare_with = self.get_test_default_args()
widget_list=self.widget_factory.get_widgetlist()
#print "The widget list is like :",widget_list
for argument_name,argument_options in compare_with.iteritems():
assert widget_list.has_key(argument_name) == True
#print "The argument name is :",argument_name
#because some of them dont have it like boolean
if argument_options.has_key('default'):
assert argument_options['default'] == getattr(widget_list[argument_name],'default')
if argument_options.has_key("description"):
assert argument_options['description']==getattr(widget_list[argument_name],'help_text')
if argument_options.has_key("options"):
assert argument_options['options'] == getattr(widget_list[argument_name],"options")
#that should be enough
def test_get_widgetlist_object(self):
compare_with = self.get_test_default_args()
widget_list_object = self.widget_factory.get_widgetlist_object()
#print widget_list_object
all_fields = [getattr(field,"name") for field in widget_list_object]
#print all_fields
for argument_name in compare_with.keys():
print argument_name
assert argument_name in all_fields
#print getattr(widget_list_object,argument_name)
def test_remote_form(self):
schema_factory = WidgetSchemaFactory(self.get_test_default_args())
schema_validator=schema_factory.get_ready_schema()
widget_list_object = self.widget_factory.get_widgetlist_object()
remote_form = RemoteFormAutomation(widget_list_object,schema_validator)
#print remote_form
def test_remote_form_factory(self):
from turbogears.view import load_engines
load_engines()
# WidgetsList object
widget_list_object = self.widget_factory.get_widgetlist_object()
#print widget_list_object
remote_form = RemoteFormFactory(widget_list_object).get_remote_form()
#it is a key,value dict
widget_list=self.widget_factory.get_widgetlist()
#print widget_list
all_fields = [getattr(field,"name") for field in remote_form.fields]
#print all_fields
#will check if the remote form object hass all the names in it
for argument_name in widget_list.items():
argument_name in all_fields
#print remote_form.render()
def get_test_default_args(self):
return {
'string_default':{
'type':'string',
'default':'default string',
'optional':False,
'description':'default description'
},
'int_default':{
'type':'int',
'default':'default int',
'optional':False,
'description':'default description'
},
#no sense to have default
'boolean_default':{
'type':'boolean',
'optional':False,
'description':'default description'
},
'float_default':{
'type':'float',
'default':'default float',
'optional':False,
'description':'default description'
},
'hash_default':{
'type':'hash',
'default':'default hash',
'optional':False,
'description':'default description'
},
'list_default':{
'type':'list',
'default':'default list',
'optional':False,
'description':'default description'
},
#will be converted to dropdown
'special_string':{
'type':'string',
'default':'myfirst',
'options':['myfirst','mysecond','mythird'],
'optional':False,
'description':'default dropdown list'
}
}
