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
},
]
},
]
}
