def runtest(): # # ------------------------------------------------------------------- # Mocking setup: Provide overrides for some of the component methods # ------------------------------------------------------------------- # class MyBaseCapabilities(BaseCapabilities): def accessResource(self, resource_uri, input=None, params=None, method=HTTP.GET): return RESOURCE_DICT[resource_uri] # # -------------------------------------------------------------------- # Provide a mock for the request header. Not all components need this, # but one of the service methods of this component actually accesses # the request header. # -------------------------------------------------------------------- # class MyRequest(RestxHttpRequest): def getRequestURI(self): return "http://foo.com" def getRequestHeaders(self): return { "foo" : [ "one", "two" ] } # # ------------------------------------------------------------------- # The actual tests # ------------------------------------------------------------------- # # # Test 1: Always prefix, two matches # rctp = dict( api_key = "abcdefg", foo_1 = None, foo_2 = None, foo_list = [], bar_list = ParameterDefNumberList.listToArray([]), ) # Create a component with our mock capabilities and request classes c = make_component(rctp, TestComponent, MyBaseCapabilities, MyRequest) res = c.foobar(HttpMethod.GET, None, "xyz", BigDecimal(10)) # This is a Java component, so we can call the languageStructToPython() method # to convert the output data into a native Python structure. out = languageStructToPython(c, res.entity) data = [ u"Some text", 123, { u"foo" : u"This is a test", u"bar" : { u"some ArrayList" : [ u"Blah", 12345 ], u"some value" : 1, u"another value" : u"Some text" } } ] test_evaluator("Test 1", compare_any(data, out)) return get_test_result()
def __javaServiceMethodProxy(component, request, method, method_name, input, params, http_method, is_proxy_component): """ Calls service methods in Java components. Prepares parameters, converts exceptions and results. """ # We remove the resource creation time parameters from the map and # assign them directly to the component as new attributes. After that, # the pruned parameter map can be passed as keyword arg dict to the # service method. if is_proxy_component: proxy_component_param_map = dict() for name in component.componentDescriptor.getParamMap().keySet(): if name in params: if type(component.componentDescriptor.getParamMap().get(name)) is ParameterDefNumber: # Why do we have this? The default type for numeric parameters is # BigDecimal. We can't just assign a float (or other numeric value) # to a BigDecimal variable. Instead, we need to create a new # instance of that type explicitly. if is_proxy_component: proxy_component_param_map[name] = BigDecimal(params[name]) else: setattr(component, name, BigDecimal(params[name])) else: if is_proxy_component: proxy_component_param_map[name] = params[name] else: if type(component.componentDescriptor.getParamMap().get(name)) is ParameterDefNumberList: setattr(component, name, ParameterDefNumberList.listToArray([ BigDecimal(x) for x in params[name] ])) else: setattr(component, name, params[name]) del params[name] if is_proxy_component: proxy_param_func = getattr(component, "_setResourceParams") proxy_param_func(proxy_component_param_map) try: param_order = component.getParameterOrder()[method_name] param_types = component.getParameterTypes()[method_name] # Assemble the list of additional service method parameters. We need # to perform a case, so we combine the type list and parameter name list, # index the parameter map and perform the cast all in one swoop. if param_order and param_types: # Yes, the following CAN be written as a single line with list comprehension, # but then the 'reader comprehension' suffers. So, I wrote it out explicitly. arglist = list() for param_type, name in zip(param_types, param_order): param_value = params[name] if param_type != type(param_value): # Some type conversion is required arglist.append(param_type(param_value)) else: # Type is already in the right argument (often the case when a default # value was specified). arglist.append(param_value) else: arglist = list() # Importing at this odd place here avoids circular imports in other places from resource_accessor import ResourceAccessor # Provide a conversion methods specific to this component's language. # Passing them to ResourceAccessor means that I don't have to import those # symbols in the resource_accessor module. component.resourceAccessor = ResourceAccessor(__javaStructToPython, __pythonStructToJava) if type(input) in [ str, unicode ]: input = String(input if input is not None else "") if not is_proxy_component: res = method(http_method, input, *arglist) else: proxy_arg_list = [ http_method, input ] proxy_arg_list.extend(arglist) res = method(method_name, proxy_arg_list) except RestxException, e: raise e