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 test_int_validator(self): wf = WidgetSchemaFactory(self.get_int_params()) schema_man=wf.get_ready_schema() for argument_name,arg_options in self.get_int_params().iteritems(): #print argument_name assert getattr(schema_man,'fields').has_key(argument_name)==True current_schema_object = getattr(schema_man,'fields')[argument_name] #print " ",argument_name," : ",getattr(schema_man,argument_name) #if the argument includes some range if arg_options.has_key('range'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(current_schema_object,'max') == arg_options['range'][1] assert getattr(current_schema_object,'min') == arg_options['range'][0] if arg_options.has_key('min'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(current_schema_object,'min') == arg_options['min'] if arg_options.has_key('max'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(current_schema_object,'max') == arg_options['max'] if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(current_schema_object,'not_empty') == arg_options['optional'] print "Happy test!"
def test_string_validator(self): wf = WidgetSchemaFactory(self.get_string_params()) schema_man=wf.get_ready_schema() conversion_schema = { 'max_length':'max', 'min_length':'min', 'validator':'regex' } #do better test here for argument_name,arg_options in self.get_string_params().iteritems(): #print getattr(schema_man,'fields') assert getattr(schema_man,'fields').has_key(argument_name) == True current_schema_object = getattr(schema_man,'fields')[argument_name] #not very efficient but it si just a test :) if argument_name == 'string_mix': continue if arg_options.has_key('max_length'): assert getattr(current_schema_object,'max') == arg_options['max_length'] if arg_options.has_key('min_length'): assert getattr(current_schema_object,'min') == arg_options['min_length'] if arg_options.has_key('validator'): assert getattr(current_schema_object,'regex') if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(current_schema_object,'not_empty') == arg_options['optional'] print "Happy tests !"
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 test_list_validator(self,the_type='list'): if the_type == 'list': testing_data = self.get_list_params() else: testing_data = self.get_hash_params() wf = WidgetSchemaFactory(testing_data) schema_man=wf.get_ready_schema() for argument_name,arg_options in testing_data.iteritems(): #print argument_name #should all the argument names really #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(schema_man,'fields').has_key(argument_name)==True current_schema_object = getattr(schema_man,'fields')[argument_name] if arg_options.has_key('validator'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(current_schema_object,'regex_string') == arg_options['validator'] if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(current_schema_object,'not_empty') == arg_options['optional'] print "Happy test!"
def test_string_validator(self): wf = WidgetSchemaFactory(self.get_string_params()) schema_man=wf.get_ready_schema() conversion_schema = { 'max_length':'max', 'min_length':'min', 'validator':'regex' } #do better test here for argument_name,arg_options in self.get_string_params().iteritems(): #print argument_name assert hasattr(schema_man,argument_name)==True #not very efficient but it si just a test :) if argument_name != 'string_mix': for arg,value in arg_options.iteritems(): #print getattr(schema_man,argument_name) if conversion_schema.has_key(arg): if hasattr(getattr(schema_man,argument_name),conversion_schema[arg]): #print arg,value #couldnt find a way to test it !?? if arg != 'validator': assert getattr(getattr(schema_man,argument_name),conversion_schema[arg])==value #print getattr(getattr(schema_man,argument_name),conversion_schema[arg]) else: #just print it to see what is inside because the test will be very hardcoded otherwise #print getattr(schema_man,argument_name) continue print "Happy tests !"
def test_string_validator(self): wf = WidgetSchemaFactory(self.get_string_params()) schema_man = wf.get_ready_schema() conversion_schema = { 'max_length': 'max', 'min_length': 'min', 'validator': 'regex' } #do better test here for argument_name, arg_options in self.get_string_params().iteritems(): #print getattr(schema_man,'fields') assert getattr(schema_man, 'fields').has_key(argument_name) == True current_schema_object = getattr(schema_man, 'fields')[argument_name] #not very efficient but it si just a test :) if argument_name == 'string_mix': continue if arg_options.has_key('max_length'): assert getattr(current_schema_object, 'max') == arg_options['max_length'] if arg_options.has_key('min_length'): assert getattr(current_schema_object, 'min') == arg_options['min_length'] if arg_options.has_key('validator'): assert getattr(current_schema_object, 'regex') if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(current_schema_object, 'not_empty') == arg_options['optional'] print "Happy tests !"
def test_float_validator(self): wf = WidgetSchemaFactory(self.get_float_params()) schema_man = wf.get_ready_schema() for argument_name, arg_options in self.get_float_params().iteritems(): #print argument_name assert getattr(schema_man, 'fields').has_key(argument_name) == True current_schema_object = getattr(schema_man, 'fields')[argument_name] #print " ",argument_name," : ",getattr(schema_man,argument_name) if arg_options.has_key('min'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(current_schema_object, 'min') == arg_options['min'] if arg_options.has_key('max'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(current_schema_object, 'max') == arg_options['max'] if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(current_schema_object, 'not_empty') == arg_options['optional'] print "Happy test!"
def test_list_validator(self, the_type='list'): if the_type == 'list': testing_data = self.get_list_params() else: testing_data = self.get_hash_params() wf = WidgetSchemaFactory(testing_data) schema_man = wf.get_ready_schema() for argument_name, arg_options in testing_data.iteritems(): #print argument_name #should all the argument names really #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(schema_man, 'fields').has_key(argument_name) == True current_schema_object = getattr(schema_man, 'fields')[argument_name] if arg_options.has_key('validator'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(current_schema_object, 'regex_string') == arg_options['validator'] if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(current_schema_object, 'not_empty') == arg_options['optional'] print "Happy test!"
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 test_bool_validator(self): testing_data = self.get_bool_params() wf = WidgetSchemaFactory(testing_data) schema_man=wf.get_ready_schema() for argument_name,arg_options in testing_data.iteritems(): #print argument_name #should all the argument names really assert hasattr(schema_man,argument_name)==True #print " ",argument_name," : ",getattr(schema_man,argument_name) if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(getattr(schema_man,argument_name),'not_empty') == arg_options['optional'] print "Happy test!"
def test_bool_validator(self): testing_data = self.get_bool_params() wf = WidgetSchemaFactory(testing_data) schema_man = wf.get_ready_schema() for argument_name, arg_options in testing_data.iteritems(): #print argument_name #should all the argument names really assert getattr(schema_man, 'fields').has_key(argument_name) == True current_schema_object = getattr(schema_man, 'fields')[argument_name] #print " ",argument_name," : ",getattr(schema_man,argument_name) if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(current_schema_object, 'not_empty') == arg_options['optional'] print "Happy test!"
def test_float_validator(self): wf = WidgetSchemaFactory(self.get_float_params()) schema_man=wf.get_ready_schema() for argument_name,arg_options in self.get_float_params().iteritems(): #print argument_name assert hasattr(schema_man,argument_name)==True #print " ",argument_name," : ",getattr(schema_man,argument_name) if arg_options.has_key('min'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(getattr(schema_man,argument_name),'min') == arg_options['min'] if arg_options.has_key('max'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert getattr(getattr(schema_man,argument_name),'max') == arg_options['max'] if arg_options.has_key('optional'): #print " ",argument_name," : ",getattr(schema_man,argument_name) assert not getattr(getattr(schema_man,argument_name),'not_empty') == arg_options['optional'] print "Happy test!"
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 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)