robotframework-openapitools 1.0.0b2__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

OpenApiDriver/openapi_executors.py

@@ -185,8 +185,8 @@ class OpenApiExecutors(OpenApiLibCore):
         # in case of a status code indicating an error, ensure the error occurs
         if status_code >= int(HTTPStatus.BAD_REQUEST):
             invalidation_keyword_data = {
-                "get_invalid_json_data": [
-                    "get_invalid_json_data",
+                "get_invalid_body_data": [
+                    "get_invalid_body_data",
                     url,
                     method,
                     status_code,
@@ -201,13 +201,13 @@ class OpenApiExecutors(OpenApiLibCore):
             invalidation_keywords = []
 
             if request_data.dto.get_body_relations_for_error_code(status_code):
-                invalidation_keywords.append("get_invalid_json_data")
+                invalidation_keywords.append("get_invalid_body_data")
             if request_data.dto.get_parameter_relations_for_error_code(status_code):
                 invalidation_keywords.append("get_invalidated_parameters")
             if invalidation_keywords:
                 if (
                     invalidation_keyword := choice(invalidation_keywords)
-                ) == "get_invalid_json_data":
+                ) == "get_invalid_body_data":
                     json_data = run_keyword(
                         *invalidation_keyword_data[invalidation_keyword]
                     )
@@ -225,13 +225,13 @@ class OpenApiExecutors(OpenApiLibCore):
                     params, headers = run_keyword(
                         *invalidation_keyword_data["get_invalidated_parameters"]
                     )
-                    if request_data.dto_schema:
+                    if request_data.body_schema:
                         json_data = run_keyword(
-                            *invalidation_keyword_data["get_invalid_json_data"]
+                            *invalidation_keyword_data["get_invalid_body_data"]
                         )
-                elif request_data.dto_schema:
+                elif request_data.body_schema:
                     json_data = run_keyword(
-                        *invalidation_keyword_data["get_invalid_json_data"]
+                        *invalidation_keyword_data["get_invalid_body_data"]
                     )
                 else:
                     raise SkipExecution(

OpenApiDriver/openapi_reader.py

@@ -1,10 +1,12 @@
 """Module holding the OpenApiReader reader_class implementation."""
 
-from typing import Any
+from typing import Sequence
 
 from DataDriver.AbstractReaderClass import AbstractReaderClass
 from DataDriver.ReaderConfig import TestCaseData
 
+from OpenApiLibCore.models import PathItemObject
+
 
 class Test:
     """
@@ -16,7 +18,7 @@ class Test:
         self.method = method.lower()
         self.response = str(response)
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, type(self)):
             return False
         return (
@@ -33,7 +35,7 @@ class OpenApiReader(AbstractReaderClass):
         test_data: list[TestCaseData] = []
 
         read_paths_method = getattr(self, "read_paths_method")
-        paths: dict[str, Any] = read_paths_method()
+        paths: dict[str, PathItemObject] = read_paths_method()
         self._filter_paths(paths)
 
         ignored_responses_ = [
@@ -43,15 +45,12 @@ class OpenApiReader(AbstractReaderClass):
         ignored_tests = [Test(*test) for test in getattr(self, "ignored_testcases", [])]
 
         for path, path_item in paths.items():
+            path_operations = path_item.get_operations()
+
             # by reseversing the items, post/put operations come before get and delete
-            for item_name, item_data in reversed(path_item.items()):
-                # this level of the OAS also contains data that's not related to a
-                # path operation
-                if item_name not in ["get", "put", "post", "delete", "patch"]:
-                    continue
-                method, method_data = item_name, item_data
-                tags_from_spec = method_data.get("tags", [])
-                for response in method_data.get("responses"):
+            for method, operation_data in reversed(path_operations.items()):
+                tags_from_spec = operation_data.tags
+                for response in operation_data.responses.keys():
                     # 'default' applies to all status codes that are not specified, in
                     # which case we don't know what to expect and therefore can't verify
                     if (
@@ -76,7 +75,7 @@ class OpenApiReader(AbstractReaderClass):
                     )
         return test_data
 
-    def _filter_paths(self, paths: dict[str, Any]) -> None:
+    def _filter_paths(self, paths: dict[str, PathItemObject]) -> None:
         def matches_include_pattern(path: str) -> bool:
             for included_path in included_paths:
                 if path == included_path:
@@ -111,5 +110,5 @@ class OpenApiReader(AbstractReaderClass):
                     paths.pop(path)
 
 
-def _get_tag_list(tags: list[str], method: str, response: str) -> list[str]:
+def _get_tag_list(tags: Sequence[str], method: str, response: str) -> list[str]:
     return [*tags, f"Method: {method.upper()}", f"Response: {response}"]

OpenApiDriver/openapidriver.libspec

@@ -1,12 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<keywordspec name="OpenApiDriver" type="LIBRARY" format="HTML" scope="SUITE" generated="2025-04-03T11:37:57+00:00" specversion="6" source="/workspaces/robotframework-openapitools/src/OpenApiDriver/openapidriver.py" lineno="358">
-<version>1.0.0b2</version>
+<keywordspec name="OpenApiDriver" type="LIBRARY" format="HTML" scope="SUITE" generated="2025-05-11T17:23:01+00:00" specversion="6" source="/workspaces/robotframework-openapitools/src/OpenApiDriver/openapidriver.py" lineno="358">
+<version>1.0.0b3</version>
 <doc>&lt;p&gt;Visit the &lt;a href="https://github.com/MarketSquare/robotframework-openapidriver"&gt;library page&lt;/a&gt; for an introduction and examples.&lt;/p&gt;</doc>
 <tags>
 </tags>
 <inits>
 <init name="__init__" lineno="150">
-<arguments repr="source: str, origin: str = , base_path: str = , included_paths: Iterable[str] = frozenset(), ignored_paths: Iterable[str] = frozenset(), ignored_responses: Iterable[int] = frozenset(), ignored_testcases: Iterable[tuple[str, str, int]] = frozenset(), response_validation: ValidationLevel = WARN, disable_server_validation: bool = True, mappings_path: str | Path = , invalid_property_default_response: int = 422, default_id_property_name: str = id, faker_locale: str | list[str] = , require_body_for_invalid_url: bool = False, recursion_limit: int = 1, recursion_default: dict[str, JSON] | list[JSON] | str | bytes | int | float | bool | None = {}, username: str = , password: str = , security_token: str = , auth: AuthBase | None = None, cert: str | tuple[str, str] = , verify_tls: bool | str = True, extra_headers: Mapping[str, str] = {}, cookies: MutableMapping[str, str] | RequestsCookieJar | None = None, proxies: MutableMapping[str, str] | None = None">
+<arguments repr="source: str, origin: str = , base_path: str = , included_paths: Iterable[str] = frozenset(), ignored_paths: Iterable[str] = frozenset(), ignored_responses: Iterable[int] = frozenset(), ignored_testcases: Iterable[tuple[str, str, int]] = frozenset(), response_validation: ValidationLevel = WARN, disable_server_validation: bool = True, mappings_path: str | Path = , invalid_property_default_response: int = 422, default_id_property_name: str = id, faker_locale: str | list[str] = , require_body_for_invalid_url: bool = False, recursion_limit: int = 1, recursion_default: JSON = {}, username: str = , password: str = , security_token: str = , auth: AuthBase | None = None, cert: str | tuple[str, str] = , verify_tls: bool | str = True, extra_headers: Mapping[str, str] = {}, cookies: MutableMapping[str, str] | RequestsCookieJar | None = None, proxies: MutableMapping[str, str] | None = None">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="source: str">
 <name>source</name>
 <type name="str" typedoc="string"/>
@@ -101,23 +101,9 @@
 <type name="int" typedoc="integer"/>
 <default>1</default>
 </arg>
-<arg kind="POSITIONAL_OR_NAMED" required="false" repr="recursion_default: dict[str, JSON] | list[JSON] | str | bytes | int | float | bool | None = {}">
+<arg kind="POSITIONAL_OR_NAMED" required="false" repr="recursion_default: JSON = {}">
 <name>recursion_default</name>
-<type name="Union" union="true">
-<type name="dict" typedoc="dictionary">
-<type name="str" typedoc="string"/>
 <type name="JSON"/>
-</type>
-<type name="list" typedoc="list">
-<type name="JSON"/>
-</type>
-<type name="str" typedoc="string"/>
-<type name="bytes" typedoc="bytes"/>
-<type name="int" typedoc="integer"/>
-<type name="float" typedoc="float"/>
-<type name="bool" typedoc="boolean"/>
-<type name="None" typedoc="None"/>
-</type>
 <default>{}</default>
 </arg>
 <arg kind="POSITIONAL_OR_NAMED" required="false" repr="username: str = ">
@@ -350,17 +336,6 @@
 <usage>__init__</usage>
 </usages>
 </type>
-<type name="bytes" type="Standard">
-<doc>&lt;p&gt;Strings are converted to bytes so that each Unicode code point below 256 is directly mapped to a matching byte. Higher code points are not allowed. Robot Framework's &lt;code&gt;\xHH&lt;/code&gt; escape syntax is convenient with bytes having non-printable values.&lt;/p&gt;
-&lt;p&gt;Examples: &lt;code&gt;good&lt;/code&gt;, &lt;code&gt;hyvä&lt;/code&gt; (same as &lt;code&gt;hyv\xE4&lt;/code&gt;), &lt;code&gt;\x00&lt;/code&gt; (the null byte)&lt;/p&gt;</doc>
-<accepts>
-<type>string</type>
-<type>bytearray</type>
-</accepts>
-<usages>
-<usage>__init__</usage>
-</usages>
-</type>
 <type name="dictionary" type="Standard">
 <doc>&lt;p&gt;Strings must be Python &lt;a href="https://docs.python.org/library/stdtypes.html#dict"&gt;dictionary&lt;/a&gt; literals. They are converted to actual dictionaries using the &lt;a href="https://docs.python.org/library/ast.html#ast.literal_eval"&gt;ast.literal_eval&lt;/a&gt; function. They can contain any values &lt;code&gt;ast.literal_eval&lt;/code&gt; supports, including dictionaries and other containers.&lt;/p&gt;
 &lt;p&gt;If the type has nested types like &lt;code&gt;dict[str, int]&lt;/code&gt;, items are converted to those types automatically. This in new in Robot Framework 6.0.&lt;/p&gt;
@@ -373,18 +348,6 @@
 <usage>__init__</usage>
 </usages>
 </type>
-<type name="float" type="Standard">
-<doc>&lt;p&gt;Conversion is done using Python's &lt;a href="https://docs.python.org/library/functions.html#float"&gt;float&lt;/a&gt; built-in function.&lt;/p&gt;
-&lt;p&gt;Starting from RF 4.1, spaces and underscores can be used as visual separators for digit grouping purposes.&lt;/p&gt;
-&lt;p&gt;Examples: &lt;code&gt;3.14&lt;/code&gt;, &lt;code&gt;2.9979e8&lt;/code&gt;, &lt;code&gt;10 000.000 01&lt;/code&gt;&lt;/p&gt;</doc>
-<accepts>
-<type>string</type>
-<type>Real</type>
-</accepts>
-<usages>
-<usage>__init__</usage>
-</usages>
-</type>
 <type name="integer" type="Standard">
 <doc>&lt;p&gt;Conversion is done using Python's &lt;a href="https://docs.python.org/library/functions.html#int"&gt;int&lt;/a&gt; built-in function. Floating point numbers are accepted only if they can be represented as integers exactly. For example, &lt;code&gt;1.0&lt;/code&gt; is accepted and &lt;code&gt;1.1&lt;/code&gt; is not.&lt;/p&gt;
 &lt;p&gt;Starting from RF 4.1, it is possible to use hexadecimal, octal and binary numbers by prefixing values with &lt;code&gt;0x&lt;/code&gt;, &lt;code&gt;0o&lt;/code&gt; and &lt;code&gt;0b&lt;/code&gt;, respectively.&lt;/p&gt;

OpenApiLibCore/__init__.py

@@ -21,7 +21,6 @@ from OpenApiLibCore.dto_base import (
     PropertyValueConstraint,
     ResourceRelation,
     UniquePropertyValueConstraint,
-    resolve_schema,
 )
 from OpenApiLibCore.dto_utils import DefaultDto
 from OpenApiLibCore.openapi_libcore import (
@@ -52,5 +51,4 @@ __all__ = [
     "ResourceRelation",
     "UniquePropertyValueConstraint",
     "ValidationLevel",
-    "resolve_schema",
 ]

OpenApiLibCore/annotations.py

@@ -1,3 +1,10 @@
 """Module holding reusable compound annotations."""
 
-JSON = dict[str, "JSON"] | list["JSON"] | str | bytes | int | float | bool | None
+from typing import Union
+
+from typing_extensions import TypeAliasType
+
+JSON = TypeAliasType(
+    "JSON",
+    "Union[dict[str, JSON], list[JSON], str, bytes, int, float, bool, None]",
+)

OpenApiLibCore/data_generation/__init__.py

@@ -3,10 +3,8 @@ Module holding the functions related to data generation
 for the requests made as part of keyword exection.
 """
 
-from .body_data_generation import get_json_data_for_dto_class
 from .data_generation_core import get_request_data
 
 __all__ = [
-    "get_json_data_for_dto_class",
     "get_request_data",
 ]

OpenApiLibCore/data_generation/body_data_generation.py

@@ -16,26 +16,41 @@ from OpenApiLibCore.dto_base import (
     PropertyValueConstraint,
 )
 from OpenApiLibCore.dto_utils import DefaultDto
+from OpenApiLibCore.models import (
+    ArraySchema,
+    ObjectSchema,
+    SchemaObjectTypes,
+    UnionTypeSchema,
+)
 from OpenApiLibCore.parameter_utils import get_safe_name_for_oas_name
 from OpenApiLibCore.protocols import GetIdPropertyNameType
-from OpenApiLibCore.value_utils import IGNORE, get_valid_value
+from OpenApiLibCore.value_utils import IGNORE
 
 
 def get_json_data_for_dto_class(
-    schema: dict[str, Any],
+    schema: SchemaObjectTypes,
     dto_class: type[Dto],
     get_id_property_name: GetIdPropertyNameType,
-    operation_id: str = "",
+    operation_id: str | None = None,
 ) -> JSON:
-    match schema.get("type"):
-        case "object":
+    if isinstance(schema, UnionTypeSchema):
+        chosen_schema = choice(schema.resolved_schemas)
+        return get_json_data_for_dto_class(
+            schema=chosen_schema,
+            dto_class=dto_class,
+            get_id_property_name=get_id_property_name,
+            operation_id=operation_id,
+        )
+
+    match schema:
+        case ObjectSchema():
             return get_dict_data_for_dto_class(
                 schema=schema,
                 dto_class=dto_class,
                 get_id_property_name=get_id_property_name,
                 operation_id=operation_id,
             )
-        case "array":
+        case ArraySchema():
             return get_list_data_for_dto_class(
                 schema=schema,
                 dto_class=dto_class,
@@ -43,22 +58,22 @@ def get_json_data_for_dto_class(
                 operation_id=operation_id,
             )
         case _:
-            return get_valid_value(value_schema=schema)
+            return schema.get_valid_value()
 
 
 def get_dict_data_for_dto_class(
-    schema: dict[str, Any],
+    schema: ObjectSchema,
     dto_class: type[Dto],
     get_id_property_name: GetIdPropertyNameType,
-    operation_id: str = "",
+    operation_id: str | None = None,
 ) -> dict[str, Any]:
     json_data: dict[str, Any] = {}
 
     property_names = get_property_names_to_process(schema=schema, dto_class=dto_class)
 
     for property_name in property_names:
-        property_schema = schema["properties"][property_name]
-        if property_schema.get("readOnly", False):
+        property_schema = schema.properties.root[property_name]
+        if property_schema.readOnly:
             continue
 
         json_data[property_name] = get_data_for_property(
@@ -73,15 +88,15 @@ def get_dict_data_for_dto_class(
 
 
 def get_list_data_for_dto_class(
-    schema: dict[str, Any],
+    schema: ArraySchema,
     dto_class: type[Dto],
     get_id_property_name: GetIdPropertyNameType,
-    operation_id: str = "",
-) -> list[Any]:
-    json_data: list[Any] = []
-    list_item_schema = schema.get("items", {})
-    min_items = schema.get("minItems", 0)
-    max_items = schema.get("maxItems", 1)
+    operation_id: str | None = None,
+) -> list[JSON]:
+    json_data: list[JSON] = []
+    list_item_schema = schema.items
+    min_items = schema.minItems if schema.minItems is not None else 0
+    max_items = schema.maxItems if schema.maxItems is not None else 1
     number_of_items_to_generate = randint(min_items, max_items)
     for _ in range(number_of_items_to_generate):
         list_item_data = get_json_data_for_dto_class(
@@ -96,29 +111,11 @@ def get_list_data_for_dto_class(
 
 def get_data_for_property(
     property_name: str,
-    property_schema: dict[str, Any],
+    property_schema: SchemaObjectTypes,
     get_id_property_name: GetIdPropertyNameType,
     dto_class: type[Dto],
-    operation_id: str,
+    operation_id: str | None,
 ) -> JSON:
-    property_type = property_schema.get("type")
-    if property_type is None:
-        property_types = property_schema.get("types")
-        if property_types is None:
-            if property_schema.get("properties") is None:
-                raise NotImplementedError
-
-            nested_data = get_json_data_for_dto_class(
-                schema=property_schema,
-                dto_class=DefaultDto,
-                get_id_property_name=get_id_property_name,
-            )
-            return nested_data
-
-        selected_type_schema = choice(property_types)
-        property_type = selected_type_schema["type"]
-        property_schema = selected_type_schema
-
     if constrained_values := get_constrained_values(
         dto_class=dto_class, property_name=property_name
     ):
@@ -144,32 +141,18 @@ def get_data_for_property(
     ) is not None:
         return dependent_id
 
-    if property_type == "object":
-        object_data = get_json_data_for_dto_class(
-            schema=property_schema,
-            dto_class=DefaultDto,
-            get_id_property_name=get_id_property_name,
-            operation_id="",
-        )
-        return object_data
-
-    if property_type == "array":
-        array_data = get_json_data_for_dto_class(
-            schema=property_schema["items"],
-            dto_class=DefaultDto,
-            get_id_property_name=get_id_property_name,
-            operation_id=operation_id,
-        )
-        return [array_data]
-
-    return get_valid_value(property_schema)
+    return get_json_data_for_dto_class(
+        schema=property_schema,
+        dto_class=DefaultDto,
+        get_id_property_name=get_id_property_name,
+    )
 
 
 def get_value_constrained_by_nested_dto(
-    property_schema: dict[str, Any],
+    property_schema: SchemaObjectTypes,
     nested_dto_class: type[Dto],
     get_id_property_name: GetIdPropertyNameType,
-    operation_id: str,
+    operation_id: str | None,
 ) -> JSON:
     nested_schema = get_schema_for_nested_dto(property_schema=property_schema)
     nested_value = get_json_data_for_dto_class(
@@ -181,23 +164,21 @@ def get_value_constrained_by_nested_dto(
     return nested_value
 
 
-def get_schema_for_nested_dto(property_schema: dict[str, Any]) -> dict[str, Any]:
-    if property_schema.get("type"):
-        return property_schema
-
-    if possible_types := property_schema.get("types"):
-        return choice(possible_types)
+def get_schema_for_nested_dto(property_schema: SchemaObjectTypes) -> SchemaObjectTypes:
+    if isinstance(property_schema, UnionTypeSchema):
+        chosen_schema = choice(property_schema.resolved_schemas)
+        return get_schema_for_nested_dto(chosen_schema)
 
-    raise NotImplementedError
+    return property_schema
 
 
 def get_property_names_to_process(
-    schema: dict[str, Any],
+    schema: ObjectSchema,
     dto_class: type[Dto],
 ) -> list[str]:
     property_names = []
 
-    for property_name in schema.get("properties", []):
+    for property_name in schema.properties.root:
         # register the oas_name
         _ = get_safe_name_for_oas_name(property_name)
         if constrained_values := get_constrained_values(
@@ -208,9 +189,9 @@ def get_property_names_to_process(
                 continue
         property_names.append(property_name)
 
-    max_properties = schema.get("maxProperties")
+    max_properties = schema.maxProperties
     if max_properties and len(property_names) > max_properties:
-        required_properties = schema.get("required", [])
+        required_properties = schema.required
         number_of_optional_properties = max_properties - len(required_properties)
         optional_properties = [
             name for name in property_names if name not in required_properties
@@ -239,7 +220,7 @@ def get_constrained_values(
 def get_dependent_id(
     dto_class: type[Dto],
     property_name: str,
-    operation_id: str,
+    operation_id: str | None,
     get_id_property_name: GetIdPropertyNameType,
 ) -> str | int | float | None:
     relations = dto_class.get_relations()