def test_enumerate_attribute_access(self): """For loop on enumerate: only attributes used in body are extracted. Since mylist is given as an argument to enumerate, a known builtin function, Py3oConvertor should be able to recognize that val refers to the elements of mylist. """ expressions = [ 'for="i, val in enumerate(mylist)"', "i", "val.var0", "val.var2", "/for", ] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) user_data = { "mylist": [ Mock(var0="0", var1=1, var2=2.0), Mock(var0=0, var1=1.0, var2="2"), Mock(var0=0.0, var1="1", var2=2), ] } json_dict = res.render(user_data) self.assertEqual( json_dict, { "mylist": [ dict(var0="0", var2=2.0), dict(var0=0, var2="2"), dict(var0=0.0, var2=2), ] }, )
def test_unknown_iterable_call(self): """For loop on unknown function call: extract the entire object""" expressions = [ 'for="i, val in not_enumerate(mylist)"', "i", "val.var0", "val.var2", "/for", ] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) user_data = { "mylist": [ Mock(var0="0", var1=1, var2=2.0), Mock(var0=0, var1=1.0, var2="2"), Mock(var0=0.0, var1="1", var2=2), ] } json_dict = res.render(user_data) self.assertEqual( json_dict, { "mylist": [ user_data["mylist"][0], user_data["mylist"][1], user_data["mylist"][2], ] }, )
def test_convertor(self): source_odt_filename = pkg_resources.resource_filename( "py3o.template", "tests/templates/py3o_if_parser.odt" ) outfilename = get_secure_filename() template = Template(source_odt_filename, outfilename) user_vars = template.get_user_variables() expressions = template.get_all_user_python_expression() py_expression = template.convert_py3o_to_python_ast(expressions) convertor = Py3oConvertor() data_struct = convertor(py_expression) assert "objects" in data_struct objs = data_struct["objects"] assert "company_label" in objs assert "name" in objs assert isinstance(objs["company_label"], Py3oName) assert isinstance(objs["name"], Py3oName) # assert data_struct == Py3oModule( # { # 'objects': Py3oArray( # { # 'company_label': Py3oName({}), # 'name': Py3oName({}) # } # ) # } # ) expected_vars = ["registration.name", "registration.company_label"] assert set(user_vars) == set(expected_vars)
def test_if_comparator(self): expressions = ['if="a in b"', "/if"] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({"a": 1, "b": [0, 1, 2]}) assert json_dict == {"a": 1, "b": [0, 1, 2]}
def test_if_global(self): expressions = ['if="mytest"', "item.myvar", "item.myvar2", "/if"] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({"item": Mock(myvar=1, myvar2=2), "mytest": 0}) assert json_dict == {"mytest": 0, "item": {"myvar": 1, "myvar2": 2}}
def test_function_array(self): expressions = ['for="var in myarray"', "myfunc(var)", "/for"] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({"myarray": [0, 1, 2, 3]}) assert json_dict == {"myarray": [0, 1, 2, 3]}
def test_if_comparator_literal(self): expressions = ['if="a == 1"', "/if"] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({"a": 1}) self.assertEqual(json_dict, {"a": 1})
def test_function_keywords(self): expressions = ["myfunc(object.var, k=object.k)"] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({"object": Mock(var=0, k=1)}) assert json_dict == {"object": {"var": 0, "k": 1}}
def _create_single_report(self, model_instance, data, save_in_attachment): """ This function to generate our py3o report """ self.ensure_one() report_xml = self.ir_actions_report_xml_id filetype = report_xml.py3o_filetype result_fd, result_path = tempfile.mkstemp( suffix='.' + filetype, prefix='p3o.report.tmp.') tmpl_data = self.get_template(model_instance) in_stream = StringIO(tmpl_data) with closing(os.fdopen(result_fd, 'w+')) as out_stream: template = Template(in_stream, out_stream, escape_false=True) localcontext = self._get_parser_context(model_instance, data) is_native = Formats().get_format(filetype).native if report_xml.py3o_is_local_fusion: template.render(localcontext) out_stream.seek(0) tmpl_data = out_stream.read() datadict = {} else: expressions = template.get_all_user_python_expression() py_expression = template.convert_py3o_to_python_ast( expressions) convertor = Py3oConvertor() data_struct = convertor(py_expression) datadict = data_struct.render(localcontext) # if not is_native or not report_xml.py3o_is_local_fusion: # # Call py3o.server to render the template in the desired format # files = { # 'tmpl_file': tmpl_data, # } # fields = { # "targetformat": filetype, # "datadict": json.dumps(datadict), # "image_mapping": "{}", # "escape_false": "on", # } # if report_xml.py3o_is_local_fusion: # fields['skipfusion'] = '1' # r = requests.post( # report_xml.py3o_server_id.url, data=fields, files=files) # if r.status_code != 200: # # server says we have an issue... let's tell that to enduser # raise UserError( # _('Fusion server error %s') % r.text, # ) # chunk_size = 1024 # with open(result_path, 'w+') as fd: # for chunk in r.iter_content(chunk_size): # fd.write(chunk) if len(model_instance) == 1: self._postprocess_report( result_path, model_instance.id, save_in_attachment) return result_path
def test_access_in_loop_variable(self): py_expr = self.__load_and_convert_template( 'tests/templates/py3o_access_in_loop_variable.odt') p = Py3oConvertor() res = p(py_expr) user_data = {'my2list': [0, 1, 2, 3, 4]} json_str = res.render(user_data) assert json_str == {'my2list': [0, 1, 2, 3, 4]}
def test_iterable_with_global_attribute(self): py_expr = self.__load_and_convert_template( 'tests/templates/py3o_iterable_with_global_attribute.odt') p = Py3oConvertor() res = p(py_expr) user_data = {'foo': Mock(my2list=[0, 1, 2, 3, 4])} json_str = res.render(user_data) assert json_str == {'foo': {'my2list': [0, 1, 2, 3, 4]}}
def test_template_function_call(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_template_function_call.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"amount": 32.123} json_dict = res.render(user_data) assert json_dict == {"amount": 32.123}
def test_bad_user_data(self): py_expr = self.__load_and_convert_template( 'tests/templates/py3o_access_global_variable_inside_loop.odt') p = Py3oConvertor() res = p(py_expr) user_data = {} with self.assertRaises(Py3oDataError): res.render(user_data)
def test_access_parent_variable_in_nested_loop(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_access_parent_variable_in_nested_loop.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"my9list": [Mock(val=10), Mock(val=11)]} json_str = res.render(user_data) assert json_str == {"my9list": [{"val": 10}, {"val": 11}]}
def test_access_global_variable(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_access_global_variable.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"var0": 0, "var1": 1, "var2": 2} json_str = res.render(user_data) assert json_str == {"var0": 0, "var1": 1, "var2": 2}
def test_enumerate(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_enumerate.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"mylist": [10, 9, 8, 7, 6]} json_dict = res.render(user_data) assert json_dict == {"mylist": [10, 9, 8, 7, 6]}
def test_test_statement(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_test_statement.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"var0": 42, "myvar": Mock(var0=43, var1="val")} json_dict = res.render(user_data) assert json_dict == {"var0": 42, "myvar": {"var0": 43, "var1": "val"}}
def test_access_variable_in_nested_loop(self): py_expr = self.__load_and_convert_template( "tests/templates/" "py3o_access_variable_in_nested_loop.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"my8list": [[10, 11, 12], [20, 21, 22, 23]]} json_str = res.render(user_data) assert json_str == {"my8list": [[10, 11, 12], [20, 21, 22, 23]]}
def test_empty_for_loop(self): u"""Test ast extraction on for loops whose body do not use any data""" expressions = ['for="var in myarray"', "/for"] py_expr = Template.convert_py3o_to_python_ast(expressions) self.assertEqual(py_expr.strip(), "for var in myarray:\n pass") p = Py3oConvertor() res = p(py_expr) data = {"myarray": [0, 1, 2, 3]} json_dict = res.render(data) self.assertEqual(json_dict, data)
def test_access_in_loop_variable_with_attribute(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_access_in_loop_variable_with_attribute.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"my3list": [Mock(val=0), Mock(val=1), Mock(val=2)]} json_str = res.render(user_data) assert json_str == {"my3list": [{"val": 0}, {"val": 1}, {"val": 2}]}
def test_access_global_variable_inside_loop(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_access_global_variable_inside_loop.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = {"global_var": Mock(val=1), "my4list": [0, 1, 2, 3]} json_str = res.render(user_data) self.assertEquals( json_str, {"global_var": dict(val=1), "my4list": [0, 1, 2, 3]} )
def test_function_keywords(self): expressions = [ 'myfunc(object.var, k=object.k)', ] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({ 'object': Mock(var=0, k=1), }) assert json_dict == {'object': {'var': 0, 'k': 1}}
def test_unpack_from_data_source(self): expressions = ['for="a, b in myarray"', "a", "b.c", "/for"] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) data = {"myarray": [(1, Mock(c=2, d=3)), (4, Mock(c=5, d=6))]} json_dict = res.render(data) self.assertEqual( json_dict, {"myarray": [[1, {"c": 2}], [4, {"c": 5}]]} )
def test_access_global_variable_inside_loop(self): py_expr = self.__load_and_convert_template( 'tests/templates/py3o_access_global_variable_inside_loop.odt' ) p = Py3oConvertor() res = p(py_expr) user_data = { 'global_var': Mock(val=1), 'my4list': [0, 1, 2, 3], } json_str = res.render(user_data) assert json_str == {'global_var': {'val': 1}}
def test_access_global_variable(self): py_expr = self.__load_and_convert_template( 'tests/templates/py3o_access_global_variable.odt') p = Py3oConvertor() res = p(py_expr) user_data = { 'var0': 0, 'var1': 1, 'var2': 2, } json_str = res.render(user_data) assert json_str == {'var0': 0, 'var1': 1, 'var2': 2}
def test_false_value(self): py_expr = self.__load_and_convert_template( "tests/templates/test_false_value.odt" ) p = Py3oConvertor() res = p(py_expr) false_mock = Mock() false_mock.__nonzero__ = lambda x: False false_mock.__bool__ = lambda x: False user_data = {"false_value": false_mock} json_dict = res.render(user_data) assert json_dict == {"false_value": u""}
def test_if_comparator(self): expressions = ['if="a in b"', '/if'] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({ 'a': 1, 'b': [0, 1, 2], }) assert json_dict == { 'a': 1, 'b': [0, 1, 2], }
def test_two_for_list_on_same_attribute(self): py_expr = self.__load_and_convert_template( "tests/templates/py3o_two_for_list_on_same_attribute.odt" ) p = Py3oConvertor() res = p(py_expr) user_data = { "foo": Mock(my2list=[0, 1, 2, 3, 4], my3list=[5, 6, 7, 8]) } json_str = res.render(user_data) assert json_str == { "foo": {"my2list": [0, 1, 2, 3, 4], "my3list": [5, 6, 7, 8]} }
def test_if_global_array(self): expressions = [ 'for="var in myarray"', 'if="var"', "var", "/if", "/for", ] py_expr = Template.convert_py3o_to_python_ast(expressions) p = Py3oConvertor() res = p(py_expr) json_dict = res.render({"myarray": list(range(0, 5))}) assert json_dict == {"myarray": list(range(0, 5))}
def test_access_parent_variable_in_nested_loop_with_attribute(self): py_expr = self.__load_and_convert_template( 'tests/templates/' 'py3o_access_parent_variable_in_nested_loop_with_attribute.odt') p = Py3oConvertor() res = p(py_expr) user_data = { 'my10list': [ Mock(my_list=[ Mock(val=10), Mock(val=11), ]), Mock(my_list=[ Mock(val=20), Mock(val=21), Mock(val=22), ]), ] } json_str = res.render(user_data) assert json_str == { 'my10list': [ { 'my_list': [ { 'val': 10 }, { 'val': 11 }, ] }, { 'my_list': [ { 'val': 20 }, { 'val': 21 }, { 'val': 22 }, ] }, ] }