robotframework-openapitools 0.4.0__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

OpenApiLibCore/data_generation/body_data_generation.py

@@ -0,0 +1,269 @@
+"""
+Module holding the functions related to (json) data generation
+for the body of requests made as part of keyword exection.
+"""
+
+from random import choice, randint, sample
+from typing import Any
+
+from robot.api import logger
+
+import OpenApiLibCore.path_functions as pf
+from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.dto_base import (
+    Dto,
+    IdDependency,
+    PropertyValueConstraint,
+)
+from OpenApiLibCore.dto_utils import DefaultDto
+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
+
+
+def get_json_data_for_dto_class(
+    schema: dict[str, Any],
+    dto_class: type[Dto],
+    get_id_property_name: GetIdPropertyNameType,
+    operation_id: str = "",
+) -> JSON:
+    match schema.get("type"):
+        case "object":
+            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":
+            return get_list_data_for_dto_class(
+                schema=schema,
+                dto_class=dto_class,
+                get_id_property_name=get_id_property_name,
+                operation_id=operation_id,
+            )
+        case _:
+            return get_valid_value(value_schema=schema)
+
+
+def get_dict_data_for_dto_class(
+    schema: dict[str, Any],
+    dto_class: type[Dto],
+    get_id_property_name: GetIdPropertyNameType,
+    operation_id: str = "",
+) -> 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):
+            continue
+
+        json_data[property_name] = get_data_for_property(
+            property_name=property_name,
+            property_schema=property_schema,
+            get_id_property_name=get_id_property_name,
+            dto_class=dto_class,
+            operation_id=operation_id,
+        )
+
+    return json_data
+
+
+def get_list_data_for_dto_class(
+    schema: dict[str, Any],
+    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)
+    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(
+            schema=list_item_schema,
+            dto_class=dto_class,
+            get_id_property_name=get_id_property_name,
+            operation_id=operation_id,
+        )
+        json_data.append(list_item_data)
+    return json_data
+
+
+def get_data_for_property(
+    property_name: str,
+    property_schema: dict[str, Any],
+    get_id_property_name: GetIdPropertyNameType,
+    dto_class: type[Dto],
+    operation_id: str,
+) -> 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
+    ):
+        constrained_value = choice(constrained_values)
+        # Check if the chosen value is a nested Dto; since a Dto is never
+        # instantiated, we can use isinstance(..., type) for this.
+        if isinstance(constrained_value, type):
+            return get_value_constrained_by_nested_dto(
+                property_schema=property_schema,
+                nested_dto_class=constrained_value,
+                get_id_property_name=get_id_property_name,
+                operation_id=operation_id,
+            )
+        return constrained_value
+
+    if (
+        dependent_id := get_dependent_id(
+            dto_class=dto_class,
+            property_name=property_name,
+            operation_id=operation_id,
+            get_id_property_name=get_id_property_name,
+        )
+    ) 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)
+
+
+def get_value_constrained_by_nested_dto(
+    property_schema: dict[str, Any],
+    nested_dto_class: type[Dto],
+    get_id_property_name: GetIdPropertyNameType,
+    operation_id: str,
+) -> JSON:
+    nested_schema = get_schema_for_nested_dto(property_schema=property_schema)
+    nested_value = get_json_data_for_dto_class(
+        schema=nested_schema,
+        dto_class=nested_dto_class,
+        get_id_property_name=get_id_property_name,
+        operation_id=operation_id,
+    )
+    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)
+
+    raise NotImplementedError
+
+
+def get_property_names_to_process(
+    schema: dict[str, Any],
+    dto_class: type[Dto],
+) -> list[str]:
+    property_names = []
+
+    for property_name in schema.get("properties", []):
+        # register the oas_name
+        _ = get_safe_name_for_oas_name(property_name)
+        if constrained_values := get_constrained_values(
+            dto_class=dto_class, property_name=property_name
+        ):
+            # do not add properties that are configured to be ignored
+            if IGNORE in constrained_values:  # type: ignore[comparison-overlap]
+                continue
+        property_names.append(property_name)
+
+    max_properties = schema.get("maxProperties")
+    if max_properties and len(property_names) > max_properties:
+        required_properties = schema.get("required", [])
+        number_of_optional_properties = max_properties - len(required_properties)
+        optional_properties = [
+            name for name in property_names if name not in required_properties
+        ]
+        selected_optional_properties = sample(
+            optional_properties, number_of_optional_properties
+        )
+        property_names = required_properties + selected_optional_properties
+
+    return property_names
+
+
+def get_constrained_values(
+    dto_class: type[Dto], property_name: str
+) -> list[JSON | type[Dto]]:
+    relations = dto_class.get_relations()
+    values_list = [
+        c.values
+        for c in relations
+        if (isinstance(c, PropertyValueConstraint) and c.property_name == property_name)
+    ]
+    # values should be empty or contain 1 list of allowed values
+    return values_list.pop() if values_list else []
+
+
+def get_dependent_id(
+    dto_class: type[Dto],
+    property_name: str,
+    operation_id: str,
+    get_id_property_name: GetIdPropertyNameType,
+) -> str | int | float | None:
+    relations = dto_class.get_relations()
+    # multiple get paths are possible based on the operation being performed
+    id_get_paths = [
+        (d.get_path, d.operation_id)
+        for d in relations
+        if (isinstance(d, IdDependency) and d.property_name == property_name)
+    ]
+    if not id_get_paths:
+        return None
+    if len(id_get_paths) == 1:
+        id_get_path, _ = id_get_paths.pop()
+    else:
+        try:
+            [id_get_path] = [
+                path for path, operation in id_get_paths if operation == operation_id
+            ]
+        # There could be multiple get_paths, but not one for the current operation
+        except ValueError:
+            return None
+
+    valid_id = pf.get_valid_id_for_path(
+        path=id_get_path, get_id_property_name=get_id_property_name
+    )
+    logger.debug(f"get_dependent_id for {id_get_path} returned {valid_id}")
+    return valid_id

OpenApiLibCore/data_generation/data_generation_core.py

@@ -0,0 +1,240 @@
+"""
+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
+from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.dto_base import (
+    Dto,
+    PropertyValueConstraint,
+    ResourceRelation,
+    resolve_schema,
+)
+from OpenApiLibCore.dto_utils import DefaultDto
+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 .body_data_generation import (
+    get_json_data_for_dto_class as _get_json_data_for_dto_class,
+)
+
+
+def get_request_data(
+    path: str,
+    method: str,
+    get_dto_class: GetDtoClassType,
+    get_id_property_name: GetIdPropertyNameType,
+    openapi_spec: dict[str, Any],
+) -> 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)
+    dto_class = get_dto_class(path=spec_path, method=method)
+    try:
+        method_spec = openapi_spec["paths"][spec_path][method]
+    except KeyError:
+        logger.info(
+            f"method '{method}' not supported on '{spec_path}, using empty spec."
+        )
+        method_spec = {}
+
+    parameters, params, headers = get_request_parameters(
+        dto_class=dto_class, method_spec=method_spec
+    )
+    if (body_spec := method_spec.get("requestBody", None)) is None:
+        dto_instance = _get_dto_instance_for_empty_body(
+            dto_class=dto_class,
+            dto_cls_name=dto_cls_name,
+            method_spec=method_spec,
+        )
+        return RequestData(
+            dto=dto_instance,
+            parameters=parameters,
+            params=params,
+            headers=headers,
+            has_body=False,
+        )
+
+    headers.update({"content-type": get_content_type(body_spec)})
+
+    content_schema = resolve_schema(get_content_schema(body_spec))
+    dto_data = _get_json_data_for_dto_class(
+        schema=content_schema,
+        dto_class=dto_class,
+        get_id_property_name=get_id_property_name,
+        operation_id=method_spec.get("operationId", ""),
+    )
+    dto_instance = _get_dto_instance_from_dto_data(
+        content_schema=content_schema,
+        dto_class=dto_class,
+        dto_data=dto_data,
+        method_spec=method_spec,
+        dto_cls_name=dto_cls_name,
+    )
+    return RequestData(
+        dto=dto_instance,
+        dto_schema=content_schema,
+        parameters=parameters,
+        params=params,
+        headers=headers,
+    )
+
+
+def _get_dto_instance_for_empty_body(
+    dto_class: type[Dto],
+    dto_cls_name: str,
+    method_spec: dict[str, Any],
+) -> Dto:
+    if dto_class == DefaultDto:
+        dto_instance: Dto = DefaultDto()
+    else:
+        dto_class = make_dataclass(
+            cls_name=method_spec.get("operationId", dto_cls_name),
+            fields=[],
+            bases=(dto_class,),
+        )
+        dto_instance = dto_class()
+    return dto_instance
+
+
+def _get_dto_instance_from_dto_data(
+    content_schema: dict[str, Any],
+    dto_class: type[Dto],
+    dto_data: JSON,
+    method_spec: dict[str, Any],
+    dto_cls_name: str,
+) -> Dto:
+    if not isinstance(dto_data, (dict, list)):
+        return DefaultDto()
+
+    if isinstance(dto_data, list):
+        raise NotImplementedError
+
+    fields = get_fields_from_dto_data(content_schema, dto_data)
+    dto_class_ = make_dataclass(
+        cls_name=method_spec.get("operationId", dto_cls_name),
+        fields=fields,
+        bases=(dto_class,),
+    )
+    dto_data = {get_safe_key(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]]]:
+    """Get a dataclasses fields list based on the content_schema and dto_data."""
+    fields: list[tuple[str, type[Any], Field[Any]]] = []
+    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:
+            # 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
+            fields.insert(0, (safe_key, type(value), field_))
+        else:
+            field_ = cast(Field[Any], field(default=None, metadata=metadata))  # 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 "{}"})
+    path_parts = path.split("/")
+    path_parts = [p.capitalize() for p in path_parts]
+    result = "".join([method, *path_parts])
+    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]]:
+    """Get the methods parameter spec and params and headers with valid data."""
+    parameters = method_spec.get("parameters", [])
+    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"]
+    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]],
+    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"]
+        # 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
+        ]
+        if constrained_values := [
+            r.values for r in relations if isinstance(r, PropertyValueConstraint)
+        ]:
+            value = choice(*constrained_values)
+            if value is IGNORE:
+                continue
+            result[parameter_name] = value
+            continue
+        value = get_valid_value(parameter_schema)
+        result[parameter_name] = value
+    return result