robotframework-openapitools 1.0.0b3__py3-none-any.whl → 1.0.0b5__py3-none-any.whl

OpenApiLibCore/data_generation/data_generation_core.py

@@ -3,26 +3,31 @@ Module holding the main functions related to data generation
 for the requests made as part of keyword exection.
 """
 
-import re
 from dataclasses import Field, field, make_dataclass
 from random import choice
 from typing import Any, cast
 
 from robot.api import logger
 
-import OpenApiLibCore.path_functions as pf
+import OpenApiLibCore.path_functions as _path_functions
 from OpenApiLibCore.annotations import JSON
 from OpenApiLibCore.dto_base import (
     Dto,
     PropertyValueConstraint,
     ResourceRelation,
-    resolve_schema,
 )
 from OpenApiLibCore.dto_utils import DefaultDto
+from OpenApiLibCore.models import (
+    ObjectSchema,
+    OpenApiObject,
+    OperationObject,
+    ParameterObject,
+    UnionTypeSchema,
+)
 from OpenApiLibCore.parameter_utils import get_safe_name_for_oas_name
 from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
 from OpenApiLibCore.request_data import RequestData
-from OpenApiLibCore.value_utils import IGNORE, get_valid_value
+from OpenApiLibCore.value_utils import IGNORE
 
 from .body_data_generation import (
     get_json_data_for_dto_class as _get_json_data_for_dto_class,
@@ -34,30 +39,35 @@ def get_request_data(
     method: str,
     get_dto_class: GetDtoClassType,
     get_id_property_name: GetIdPropertyNameType,
-    openapi_spec: dict[str, Any],
+    openapi_spec: OpenApiObject,
 ) -> RequestData:
     method = method.lower()
     dto_cls_name = get_dto_cls_name(path=path, method=method)
     # The path can contain already resolved Ids that have to be matched
     # against the parametrized paths in the paths section.
-    spec_path = pf.get_parametrized_path(path=path, openapi_spec=openapi_spec)
+    spec_path = _path_functions.get_parametrized_path(
+        path=path, openapi_spec=openapi_spec
+    )
     dto_class = get_dto_class(path=spec_path, method=method)
     try:
-        method_spec = openapi_spec["paths"][spec_path][method]
-    except KeyError:
+        path_item = openapi_spec.paths[spec_path]
+        operation_spec: OperationObject | None = getattr(path_item, method)
+        if operation_spec is None:
+            raise AttributeError
+    except AttributeError:
         logger.info(
             f"method '{method}' not supported on '{spec_path}, using empty spec."
         )
-        method_spec = {}
+        operation_spec = OperationObject(operationId="")
 
     parameters, params, headers = get_request_parameters(
-        dto_class=dto_class, method_spec=method_spec
+        dto_class=dto_class, method_spec=operation_spec
     )
-    if (body_spec := method_spec.get("requestBody", None)) is None:
+    if operation_spec.requestBody is None:
         dto_instance = _get_dto_instance_for_empty_body(
             dto_class=dto_class,
             dto_cls_name=dto_cls_name,
-            method_spec=method_spec,
+            method_spec=operation_spec,
         )
         return RequestData(
             dto=dto_instance,
@@ -67,25 +77,38 @@ def get_request_data(
             has_body=False,
         )
 
-    headers.update({"content-type": get_content_type(body_spec)})
+    body_schema = operation_spec.requestBody.schema_
+
+    if not body_schema:
+        raise ValueError(
+            f"No supported content schema found: {operation_spec.requestBody.content}"
+        )
+
+    headers.update({"content-type": operation_spec.requestBody.mime_type})
+
+    if isinstance(body_schema, UnionTypeSchema):
+        resolved_schemas = body_schema.resolved_schemas
+        body_schema = choice(resolved_schemas)
+
+    if not isinstance(body_schema, ObjectSchema):
+        raise ValueError(f"Selected schema is not an object schema: {body_schema}")
 
-    content_schema = resolve_schema(get_content_schema(body_spec))
     dto_data = _get_json_data_for_dto_class(
-        schema=content_schema,
+        schema=body_schema,
         dto_class=dto_class,
         get_id_property_name=get_id_property_name,
-        operation_id=method_spec.get("operationId", ""),
+        operation_id=operation_spec.operationId,
     )
     dto_instance = _get_dto_instance_from_dto_data(
-        content_schema=content_schema,
+        object_schema=body_schema,
         dto_class=dto_class,
         dto_data=dto_data,
-        method_spec=method_spec,
+        method_spec=operation_spec,
         dto_cls_name=dto_cls_name,
     )
     return RequestData(
         dto=dto_instance,
-        dto_schema=content_schema,
+        body_schema=body_schema,
         parameters=parameters,
         params=params,
         headers=headers,
@@ -95,13 +118,14 @@ def get_request_data(
 def _get_dto_instance_for_empty_body(
     dto_class: type[Dto],
     dto_cls_name: str,
-    method_spec: dict[str, Any],
+    method_spec: OperationObject,
 ) -> Dto:
     if dto_class == DefaultDto:
         dto_instance: Dto = DefaultDto()
     else:
+        cls_name = method_spec.operationId if method_spec.operationId else dto_cls_name
         dto_class = make_dataclass(
-            cls_name=method_spec.get("operationId", dto_cls_name),
+            cls_name=cls_name,
             fields=[],
             bases=(dto_class,),
         )
@@ -110,10 +134,10 @@ def _get_dto_instance_for_empty_body(
 
 
 def _get_dto_instance_from_dto_data(
-    content_schema: dict[str, Any],
+    object_schema: ObjectSchema,
     dto_class: type[Dto],
     dto_data: JSON,
-    method_spec: dict[str, Any],
+    method_spec: OperationObject,
     dto_cls_name: str,
 ) -> Dto:
     if not isinstance(dto_data, (dict, list)):
@@ -122,48 +146,41 @@ def _get_dto_instance_from_dto_data(
     if isinstance(dto_data, list):
         raise NotImplementedError
 
-    fields = get_fields_from_dto_data(content_schema, dto_data)
+    fields = get_fields_from_dto_data(object_schema, dto_data)
+    cls_name = method_spec.operationId if method_spec.operationId else dto_cls_name
     dto_class_ = make_dataclass(
-        cls_name=method_spec.get("operationId", dto_cls_name),
+        cls_name=cls_name,
         fields=fields,
         bases=(dto_class,),
     )
-    dto_data = {get_safe_key(key): value for key, value in dto_data.items()}
+    # dto_data = {get_safe_key(key): value for key, value in dto_data.items()}
+    dto_data = {
+        get_safe_name_for_oas_name(key): value for key, value in dto_data.items()
+    }
     return cast(Dto, dto_class_(**dto_data))
 
 
 def get_fields_from_dto_data(
-    content_schema: dict[str, Any], dto_data: dict[str, JSON]
-) -> list[tuple[str, type[Any], Field[Any]]]:
+    object_schema: ObjectSchema, dto_data: dict[str, JSON]
+) -> list[tuple[str, type[object], Field[object]]]:
     """Get a dataclasses fields list based on the content_schema and dto_data."""
-    fields: list[tuple[str, type[Any], Field[Any]]] = []
+    fields: list[tuple[str, type[object], Field[object]]] = []
+
     for key, value in dto_data.items():
-        required_properties = content_schema.get("required", [])
-        safe_key = get_safe_key(key)
-        metadata = {"original_property_name": key}
-        if key in required_properties:
+        # safe_key = get_safe_key(key)
+        safe_key = get_safe_name_for_oas_name(key)
+        # metadata = {"original_property_name": key}
+        if key in object_schema.required:
             # The fields list is used to create a dataclass, so non-default fields
             # must go before fields with a default
-            field_ = cast(Field[Any], field(metadata=metadata))  # pylint: disable=invalid-field-call
+            field_ = cast(Field[Any], field())  # pylint: disable=invalid-field-call
             fields.insert(0, (safe_key, type(value), field_))
         else:
-            field_ = cast(Field[Any], field(default=None, metadata=metadata))  # pylint: disable=invalid-field-call
+            field_ = cast(Field[Any], field(default=None))  # pylint: disable=invalid-field-call
             fields.append((safe_key, type(value), field_))
     return fields
 
 
-def get_safe_key(key: str) -> str:
-    """
-    Helper function to convert a valid JSON property name to a string that can be used
-    as a Python variable or function / method name.
-    """
-    key = key.replace("-", "_")
-    key = key.replace("@", "_")
-    if key[0].isdigit():
-        key = f"_{key}"
-    return key
-
-
 def get_dto_cls_name(path: str, method: str) -> str:
     method = method.capitalize()
     path = path.translate({ord(i): None for i in "{}"})
@@ -173,57 +190,30 @@ def get_dto_cls_name(path: str, method: str) -> str:
     return result
 
 
-def get_content_schema(body_spec: dict[str, Any]) -> dict[str, Any]:
-    """Get the content schema from the requestBody spec."""
-    content_type = get_content_type(body_spec)
-    content_schema = body_spec["content"][content_type]["schema"]
-    return resolve_schema(content_schema)
-
-
-def get_content_type(body_spec: dict[str, Any]) -> str:
-    """Get and validate the first supported content type from the requested body spec
-
-    Should be application/json like content type,
-    e.g "application/json;charset=utf-8" or "application/merge-patch+json"
-    """
-    content_types: list[str] = body_spec["content"].keys()
-    json_regex = r"application/([a-z\-]+\+)?json(;\s?charset=(.+))?"
-    for content_type in content_types:
-        if re.search(json_regex, content_type):
-            return content_type
-
-    # At present no supported for other types.
-    raise NotImplementedError(
-        f"Only content types like 'application/json' are supported. "
-        f"Content types definded in the spec are '{content_types}'."
-    )
-
-
 def get_request_parameters(
-    dto_class: Dto | type[Dto], method_spec: dict[str, Any]
-) -> tuple[list[dict[str, Any]], dict[str, Any], dict[str, str]]:
+    dto_class: Dto | type[Dto], method_spec: OperationObject
+) -> tuple[list[ParameterObject], dict[str, Any], dict[str, str]]:
     """Get the methods parameter spec and params and headers with valid data."""
-    parameters = method_spec.get("parameters", [])
+    parameters = method_spec.parameters if method_spec.parameters else []
     parameter_relations = dto_class.get_parameter_relations()
-    query_params = [p for p in parameters if p.get("in") == "query"]
-    header_params = [p for p in parameters if p.get("in") == "header"]
+    query_params = [p for p in parameters if p.in_ == "query"]
+    header_params = [p for p in parameters if p.in_ == "header"]
     params = get_parameter_data(query_params, parameter_relations)
     headers = get_parameter_data(header_params, parameter_relations)
     return parameters, params, headers
 
 
 def get_parameter_data(
-    parameters: list[dict[str, Any]],
+    parameters: list[ParameterObject],
     parameter_relations: list[ResourceRelation],
 ) -> dict[str, str]:
     """Generate a valid list of key-value pairs for all parameters."""
     result: dict[str, str] = {}
     value: Any = None
     for parameter in parameters:
-        parameter_name = parameter["name"]
+        parameter_name = parameter.name
         # register the oas_name
         _ = get_safe_name_for_oas_name(parameter_name)
-        parameter_schema = resolve_schema(parameter["schema"])
         relations = [
             r for r in parameter_relations if r.property_name == parameter_name
         ]
@@ -235,6 +225,9 @@ def get_parameter_data(
                 continue
             result[parameter_name] = value
             continue
-        value = get_valid_value(parameter_schema)
+
+        if parameter.schema_ is None:
+            continue
+        value = parameter.schema_.get_valid_value()
         result[parameter_name] = value
     return result

OpenApiLibCore/data_invalidation.py

@@ -11,22 +11,22 @@ from requests import Response
 from robot.api import logger
 from robot.libraries.BuiltIn import BuiltIn
 
+from OpenApiLibCore.annotations import JSON
 from OpenApiLibCore.dto_base import (
     NOT_SET,
     Dto,
     IdReference,
-    PathPropertiesConstraint,
     PropertyValueConstraint,
     UniquePropertyValueConstraint,
-    resolve_schema,
 )
+from OpenApiLibCore.models import ParameterObject, UnionTypeSchema
 from OpenApiLibCore.request_data import RequestData
-from OpenApiLibCore.value_utils import IGNORE, get_invalid_value, get_valid_value
+from OpenApiLibCore.value_utils import IGNORE, get_invalid_value
 
 run_keyword = BuiltIn().run_keyword
 
 
-def get_invalid_json_data(
+def get_invalid_body_data(
     url: str,
     method: str,
     status_code: int,
@@ -34,17 +34,14 @@ def get_invalid_json_data(
     invalid_property_default_response: int,
 ) -> dict[str, Any]:
     method = method.lower()
-    data_relations = request_data.dto.get_relations_for_error_code(status_code)
-    data_relations = [
-        r for r in data_relations if not isinstance(r, PathPropertiesConstraint)
-    ]
+    data_relations = request_data.dto.get_body_relations_for_error_code(status_code)
     if not data_relations:
-        if not request_data.dto_schema:
+        if request_data.body_schema is None:
             raise ValueError(
-                "Failed to invalidate: no data_relations and empty schema."
+                "Failed to invalidate: request_data does not contain a body_schema."
             )
         json_data = request_data.dto.get_invalidated_data(
-            schema=request_data.dto_schema,
+            schema=request_data.body_schema,
             status_code=status_code,
             invalid_property_default_code=invalid_property_default_response,
         )
@@ -62,8 +59,12 @@ def get_invalid_json_data(
         run_keyword("ensure_in_use", url, resource_relation)
         json_data = request_data.dto.as_dict()
     else:
+        if request_data.body_schema is None:
+            raise ValueError(
+                "Failed to invalidate: request_data does not contain a body_schema."
+            )
         json_data = request_data.dto.get_invalidated_data(
-            schema=request_data.dto_schema,
+            schema=request_data.body_schema,
             status_code=status_code,
             invalid_property_default_code=invalid_property_default_response,
         )
@@ -72,7 +73,7 @@ def get_invalid_json_data(
 
 def get_invalidated_parameters(
     status_code: int, request_data: RequestData, invalid_property_default_response: int
-) -> tuple[dict[str, Any], dict[str, str]]:
+) -> tuple[dict[str, JSON], dict[str, JSON]]:
     if not request_data.parameters:
         raise ValueError("No params or headers to invalidate.")
 
@@ -115,7 +116,7 @@ def get_invalidated_parameters(
 
     # Dto mappings may contain generic mappings for properties that are not present
     # in this specific schema
-    request_data_parameter_names = [p.get("name") for p in request_data.parameters]
+    request_data_parameter_names = [p.name for p in request_data.parameters]
     additional_relation_property_names = {
         n for n in relation_property_names if n not in request_data_parameter_names
     }
@@ -140,7 +141,7 @@ def get_invalidated_parameters(
         [parameter_data] = [
             data
             for data in request_data.parameters
-            if data["name"] == parameter_to_invalidate
+            if data.name == parameter_to_invalidate
         ]
     except Exception:
         raise ValueError(
@@ -186,7 +187,14 @@ def get_invalidated_parameters(
         else:
             valid_value = headers[parameter_to_invalidate]
 
-        value_schema = resolve_schema(parameter_data["schema"])
+        value_schema = parameter_data.schema_
+        if value_schema is None:
+            raise ValueError(f"No schema defined for parameter: {parameter_data}.")
+
+        if isinstance(value_schema, UnionTypeSchema):
+            # FIXME: extra handling may be needed in case of values_from_constraint
+            value_schema = choice(value_schema.resolved_schemas)
+
         invalid_value = get_invalid_value(
             value_schema=value_schema,
             current_value=valid_value,
@@ -204,11 +212,11 @@ def get_invalidated_parameters(
 
 def ensure_parameter_in_parameters(
     parameter_to_invalidate: str,
-    params: dict[str, Any],
-    headers: dict[str, str],
-    parameter_data: dict[str, Any],
-    values_from_constraint: list[Any],
-) -> tuple[dict[str, Any], dict[str, str]]:
+    params: dict[str, JSON],
+    headers: dict[str, JSON],
+    parameter_data: ParameterObject,
+    values_from_constraint: list[JSON],
+) -> tuple[dict[str, JSON], dict[str, JSON]]:
     """
     Returns the params, headers tuple with parameter_to_invalidate with a valid
     value to params or headers if not originally present.
@@ -220,15 +228,20 @@ def ensure_parameter_in_parameters(
         if values_from_constraint:
             valid_value = choice(values_from_constraint)
         else:
-            parameter_schema = resolve_schema(parameter_data["schema"])
-            valid_value = get_valid_value(parameter_schema)
+            value_schema = parameter_data.schema_
+            if value_schema is None:
+                raise ValueError(f"No schema defined for parameter: {parameter_data}.")
+
+            if isinstance(value_schema, UnionTypeSchema):
+                value_schema = choice(value_schema.resolved_schemas)
+            valid_value = value_schema.get_valid_value()
         if (
-            parameter_data["in"] == "query"
+            parameter_data.in_ == "query"
             and parameter_to_invalidate not in params.keys()
         ):
             params[parameter_to_invalidate] = valid_value
         if (
-            parameter_data["in"] == "header"
+            parameter_data.in_ == "header"
             and parameter_to_invalidate not in headers.keys()
         ):
             headers[parameter_to_invalidate] = str(valid_value)