Properly check for positive int

Author: Colin-b

.coveragerc

@@ -3,4 +3,5 @@ omit = pyxelrest/generated/*
 
 [report]
 exclude_lines =
+    pragma: no cover
     if __name__ == .__main__.:

pyxelrest/_common.py

@@ -2,6 +2,7 @@
 import re
 import os
 import time
+from abc import ABC, abstractmethod
 from typing import Optional, Union, List, Any, Dict
 
 
@@ -83,7 +84,7 @@ def allow_parameter(self, parameter_name: str) -> bool:
         return True
 
 
-class UDFParameter:
+class UDFParameter(ABC):
     def __init__(
         self,
         name: str,
@@ -116,8 +117,11 @@ def validate_required(self, value: Any, request_content: "RequestContent"):
             raise self._not_provided()
         self.validate_optional(value, request_content)
 
-    def validate_optional(self, value: Any, request_content: "RequestContent"):
-        pass
+    @abstractmethod
+    def validate_optional(
+        self, value: Any, request_content: "RequestContent"
+    ):  # pragma: no cover
+        ...
 
     def _not_provided(self) -> Exception:
         return Exception(f"{self.name} is required.")
@@ -184,7 +188,7 @@ def _to_positive_int(value: Union[str, int]) -> Optional[int]:
         if value:
             try:
                 value = int(value)
-                return value if value else None
+                return value if value > 0 else None
             except ValueError:
                 logger.warning(
                     f"Invalid positive value provided: {value}. Considering as not set."

tests/test_invalid_parameter.py

@@ -46,3 +46,46 @@ def test_parameter_cannot_be_parsed(responses: RequestsMock, tmpdir):
         str(exception_info.value)
         == "Unable to extract parameters from {'in': 'query', 'name': 'param', 'schema': {}, 'server_param_name': 'param'}"
     )
+
+
+def test_parameter_with_more_than_one_field_type(responses: RequestsMock, tmpdir):
+    responses.add(
+        responses.GET,
+        url="http://test/",
+        json={
+            "swagger": "2.0",
+            "paths": {
+                "/test": {
+                    "get": {
+                        "parameters": [
+                            {
+                                "in": "query",
+                                "name": "param",
+                                "type": ["string", "integer"],
+                            }
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "return value",
+                            }
+                        },
+                    }
+                }
+            },
+        },
+        match_querystring=True,
+    )
+    with pytest.raises(Exception) as exception_info:
+        loader.load(
+            tmpdir,
+            {
+                "invalid": {
+                    "open_api": {"definition": "http://test/"},
+                    "formulas": {"dynamic_array": {"lock_excel": True}},
+                }
+            },
+        )
+    assert (
+        str(exception_info.value)
+        == "Unable to guess field type amongst ['string', 'integer']"
+    )

tests/test_legacy_array.py

@@ -0,0 +1,38 @@
+from responses import RequestsMock
+
+from tests import loader
+
+
+def test_formula_prefix(responses: RequestsMock, tmpdir):
+    responses.add(
+        responses.GET,
+        url="http://test/",
+        json={
+            "swagger": "2.0",
+            "paths": {
+                "/test": {
+                    "get": {
+                        "responses": {200: {"description": "successful operation"}},
+                    }
+                }
+            },
+        },
+        match_querystring=True,
+    )
+    generated_functions = loader.load(
+        tmpdir,
+        {
+            "legacy": {
+                "open_api": {"definition": "http://test/"},
+                "formulas": {"legacy_array": {"lock_excel": True}},
+            }
+        },
+    )
+
+    responses.add(
+        responses.GET,
+        url="http://test/test",
+        json={},
+        match_querystring=True,
+    )
+    assert generated_functions.legacy_legacy_get_test() == [[""]]