10 cannot render list of strings argument (#11)

* feature: Moved test_variable

* feature: Add new types for Argument.value

Author: denisart

graphql_query/templates/argument_key_values.jinja2

@@ -0,0 +1 @@
+{{ name }}: [{% for value in values %}{{ value }}{% if not loop.last -%}, {% endif %}{% endfor %}]

graphql_query/types.py

@@ -163,9 +163,19 @@ class Argument(GraphQL2PythonQuery):
     """
 
     name: str
-    value: Union[str, 'Argument', List['Argument'], List[List['Argument']], Variable]
+    value: Union[
+        str,
+        int,
+        'Argument',
+        Variable,
+        List[str],
+        List[int],
+        List['Argument'],
+        List[List['Argument']],
+    ]
 
     _template_key_value: Template = template_env.get_template("argument_key_value.jinja2")
+    _template_key_values: Template = template_env.get_template("argument_key_values.jinja2")
     _template_key_argument: Template = template_env.get_template("argument_key_argument.jinja2")
     _template_key_variable: Template = template_env.get_template("argument_key_variable.jinja2")
     _template_key_arguments: Template = template_env.get_template("argument_key_arguments.jinja2")
@@ -175,41 +185,82 @@ class Argument(GraphQL2PythonQuery):
     def graphql_argument_name(cls, name: str):
         return assert_name(name)
 
+    def _render_for_str(self, name: str, value: str) -> str:
+        return self._template_key_value.render(name=name, value=value)
+
+    def _render_for_int(self, name: str, value: int) -> str:
+        return self._template_key_value.render(name=name, value=str(value))
+
+    def _render_for_argument(self, name: str, value: 'Argument') -> str:
+        return self._template_key_argument.render(
+            name=name,
+            argument=self._line_shift(value.render())
+        )
+
+    def _render_for_list_str(self, name: str, value: List[str]) -> str:
+        return self._template_key_values.render(name=name, values=value)
+
+    def _render_for_list_int(self, name: str, value: List[int]) -> str:
+        return self._template_key_values.render(
+            name=name, values=[str(v) for v in value]
+        )
+
+    def _render_for_list_argument(self, name: str, value: List['Argument']) -> str:
+        return self._template_key_arguments.render(
+            name=name,
+            arguments=[
+                self._line_shift(argument.render()) for argument in value
+            ]
+        )
+
+    def _render_for_list_list_argument(self, name: str, value: List[List['Argument']]) -> str:
+        return self._template_key_objects.render(
+            name=name,
+            list_arguments=[
+                [
+                    self._line_shift(self._line_shift(argument.render()))
+                    for argument in arguments
+                ] for arguments in value
+            ]
+        )
+
+    def _render_for_variable(self, name: str, value: Variable) -> str:
+        return self._template_key_variable.render(
+            name=name,
+            value=value.name
+        )
+
     def render(self) -> str:
+        # pylint: disable=too-many-return-statements
         if isinstance(self.value, str):
-            return self._template_key_value.render(name=self.name, value=self.value)
+            return self._render_for_str(self.name, self.value)
+
+        if isinstance(self.value, int):
+            return self._render_for_int(self.name, self.value)
 
         if isinstance(self.value, Argument):
-            return self._template_key_argument.render(
-                name=self.name,
-                argument=self._line_shift(self.value.render())
-            )
+            return self._render_for_argument(self.name, self.value)
 
         if isinstance(self.value, Variable):
-            return self._template_key_variable.render(
-                name=self.name,
-                value=self.value.name
-            )
+            return self._render_for_variable(self.name, self.value)
+
+        if isinstance(self.value, list) and (len(self.value) == 0):
+            return self._render_for_list_str(self.name, self.value)  # type: ignore
 
         if isinstance(self.value, list) and isinstance(self.value[0], Argument):
             # self.value is List[Argument]
-            return self._template_key_arguments.render(
-                name=self.name,
-                arguments=[
-                    self._line_shift(argument.render()) for argument in self.value  # type: ignore
-                ]
-            )
+            return self._render_for_list_argument(self.name, self.value)  # type: ignore
+
+        if isinstance(self.value, list) and isinstance(self.value[0], str):
+            # self.value is List[str]
+            return self._render_for_list_str(self.name, self.value)  # type: ignore
+
+        if isinstance(self.value, list) and isinstance(self.value[0], int):
+            # self.value is List[str]
+            return self._render_for_list_int(self.name, self.value)  # type: ignore
 
         # self.value is List[List[Argument]]
-        return self._template_key_objects.render(
-            name=self.name,
-            list_arguments=[
-                [
-                    self._line_shift(self._line_shift(argument.render()))  # type: ignore
-                    for argument in arguments
-                ] for arguments in self.value
-            ]
-        )
+        return self._render_for_list_list_argument(self.name, self.value)  # type: ignore
 
 
 class Directive(GraphQL2PythonQuery):

tests/test_argument.py

@@ -0,0 +1,134 @@
+import pytest
+
+from graphql_query import Argument, Variable
+
+
+def test_value_is_str():
+    assert Argument(name="arg1", value="VALUE1").render() == "arg1: VALUE1"
+    assert Argument(name="id", value='"1000"').render() == 'id: "1000"'
+    assert Argument(name="length", value='911').render() == 'length: 911'
+    assert Argument(name="unit", value="null").render() == "unit: null"
+
+
+def test_value_is_int():
+    assert Argument(name="length", value=911).render() == 'length: 911'
+    assert Argument(name="length", value=0).render() == 'length: 0'
+    assert Argument(name="length", value=-1).render() == 'length: -1'
+
+
+def test_value_is_list_str():
+    assert Argument(name="someListArgument", value=['"123"']).render() == 'someListArgument: ["123"]'
+    assert Argument(name="someListArgument", value=[]).render() == 'someListArgument: []'
+    assert Argument(name="someListArgument", value=['"123", "456"']).render() == 'someListArgument: ["123", "456"]'
+
+
+def test_value_is_list_int():
+    assert Argument(name="someListArgument", value=[123]).render() == 'someListArgument: [123]'
+    assert Argument(name="someListArgument", value=[]).render() == 'someListArgument: []'
+    assert Argument(name="someListArgument", value=[123, 456]).render() == 'someListArgument: [123, 456]'
+
+
+@pytest.mark.parametrize(
+    "name, value, result",
+    [
+        ("filter", Argument(name="field", value=123), "filter: {\n  field: 123\n}"),
+        ("filter", Argument(name="field", value="VALUE"), "filter: {\n  field: VALUE\n}"),
+        ("filter", Argument(name="field", value='"value"'), 'filter: {\n  field: "value"\n}'),
+        ("filter", Argument(name="field", value=[123, -456]), "filter: {\n  field: [123, -456]\n}"),
+        (
+            "filter",
+            Argument(name="field", value=['"value1"', '"value2"']),
+            'filter: {\n  field: ["value1", "value2"]\n}'
+        ),
+        (
+            "filter",
+            Argument(name="field", value=Variable(name="var", type="Variable")),
+            'filter: {\n  field: $var\n}'
+        )
+    ]
+)
+def test_value_is_argument(name: str, value: Argument, result: str):
+    arg = Argument(name=name, value=value)
+    assert arg.render() == result
+
+
+def test_value_is_variable():
+    var = Variable(name="var", type="Variable")
+    arg = Argument(name="field", value=var)
+    assert arg.render() == 'field: $var'
+
+
+def test_value_is_list_of_args():
+    arg = Argument(
+        name="filter",
+        value=[
+            Argument(name="arg1", value="VALUE1"),
+            Argument(name="arg2", value="VALUE2")
+        ]
+    )
+    assert arg.render() == "filter: {\n  arg1: VALUE1\n  arg2: VALUE2\n}"
+
+
+def test_value_is_args_with_args():
+    arg = Argument(
+        name="filter1",
+        value=[
+            Argument(
+                name="filter2",
+                value=[
+                    Argument(name="arg1", value="VALUE1"),
+                    Argument(name="arg2", value="VALUE2")
+                ]
+            )
+        ]
+    )
+    assert arg.render() == "filter1: {\n  filter2: {\n    arg1: VALUE1\n    arg2: VALUE2\n  }\n}"
+
+
+def test_value_long():
+    arg = Argument(
+        name="filter1",
+        value=[
+            Argument(
+                name="filter2",
+                value=[
+                    Argument(name="arg1", value="VALUE1"),
+                    Argument(name="filter3", value=Argument(name="arg2", value="VALUE2"))
+                ]
+            )
+        ]
+    )
+    assert arg.render() == """filter1: {
+  filter2: {
+    arg1: VALUE1
+    filter3: {
+      arg2: VALUE2
+    }
+  }
+}"""
+
+
+def test_value_if_list_of_list_of_args():
+    arg = Argument(
+        name="lessons",
+        value=[
+            [
+                Argument(name="title", value='"lesson title"'),
+                Argument(name="filePath", value='"static-resource-path"')
+            ],
+            [
+                Argument(name="title", value='"lesson title 2"'),
+                Argument(name="filePath", value='"static-resource-path 2"')
+            ],
+        ],
+    )
+    assert arg.render() == """lessons: [
+  {
+    title: "lesson title"
+    filePath: "static-resource-path"
+  }
+  {
+    title: "lesson title 2"
+    filePath: "static-resource-path 2"
+  }
+]"""

tests/test_argument/__init__.py

@@ -11,6 +11,7 @@
         "variable.jinja2",
         # for Argument
         "argument_key_value.jinja2",
+        "argument_key_values.jinja2",
         "argument_key_argument.jinja2",
         "argument_key_variable.jinja2",
         "argument_key_arguments.jinja2",

tests/test_argument/test_argument.py

@@ -4,8 +4,6 @@
 
 from graphql_query import Variable
 
-from .data import var_ep, var_first, var_review
-
 
 @pytest.mark.parametrize(
     "name, var_type, default, result",
@@ -23,9 +21,9 @@ def test_variable(name: str, var_type: str, default: Optional[str], result: str)
 @pytest.mark.parametrize(
     "var, result",
     [
-        (var_ep, "$ep: Episode!"),
-        (var_first, "$first: Int = 3"),
-        (var_review, "$review: ReviewInput!"),
+        (Variable(name="ep", type="Episode!"), "$ep: Episode!"),
+        (Variable(name="first", type="Int", default="3"), "$first: Int = 3"),
+        (Variable(name="review", type="ReviewInput!"), "$review: ReviewInput!"),
     ]
 )
 def test_variable_from_data(var: Variable, result: str):