robotframework-openapitools 0.3.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

OpenApiLibCore/data_generation/body_data_generation.py

@@ -0,0 +1,250 @@
+"""
+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 _path_functions
+from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.dto_base import (
+    Dto,
+    IdDependency,
+    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
+
+
+def get_json_data_for_dto_class(
+    schema: SchemaObjectTypes,
+    dto_class: type[Dto],
+    get_id_property_name: GetIdPropertyNameType,
+    operation_id: str | None = None,
+) -> JSON:
+    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 ArraySchema():
+            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 schema.get_valid_value()
+
+
+def get_dict_data_for_dto_class(
+    schema: ObjectSchema,
+    dto_class: type[Dto],
+    get_id_property_name: GetIdPropertyNameType,
+    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.root[property_name]  # type: ignore[union-attr]
+        if property_schema.readOnly:
+            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: ArraySchema,
+    dto_class: type[Dto],
+    get_id_property_name: GetIdPropertyNameType,
+    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(
+            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: SchemaObjectTypes,
+    get_id_property_name: GetIdPropertyNameType,
+    dto_class: type[Dto],
+    operation_id: str | None,
+) -> JSON:
+    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
+
+    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: SchemaObjectTypes,
+    nested_dto_class: type[Dto],
+    get_id_property_name: GetIdPropertyNameType,
+    operation_id: str | None,
+) -> 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: SchemaObjectTypes) -> SchemaObjectTypes:
+    if isinstance(property_schema, UnionTypeSchema):
+        chosen_schema = choice(property_schema.resolved_schemas)
+        return get_schema_for_nested_dto(chosen_schema)
+
+    return property_schema
+
+
+def get_property_names_to_process(
+    schema: ObjectSchema,
+    dto_class: type[Dto],
+) -> list[str]:
+    property_names = []
+
+    for property_name in schema.properties.root:  # type: ignore[union-attr]
+        # 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.maxProperties
+    if max_properties and len(property_names) > max_properties:
+        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
+        ]
+        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 | None,
+    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 = _path_functions.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,233 @@
+"""
+Module holding the main functions related to data generation
+for the requests made as part of keyword exection.
+"""
+
+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 _path_functions
+from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.dto_base import (
+    Dto,
+    PropertyValueConstraint,
+    ResourceRelation,
+)
+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
+
+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: 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 = _path_functions.get_parametrized_path(
+        path=path, openapi_spec=openapi_spec
+    )
+    dto_class = get_dto_class(path=spec_path, method=method)
+    try:
+        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."
+        )
+        operation_spec = OperationObject(operationId="")
+
+    parameters, params, headers = get_request_parameters(
+        dto_class=dto_class, method_spec=operation_spec
+    )
+    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=operation_spec,
+        )
+        return RequestData(
+            dto=dto_instance,
+            parameters=parameters,
+            params=params,
+            headers=headers,
+            has_body=False,
+        )
+
+    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}")
+
+    dto_data = _get_json_data_for_dto_class(
+        schema=body_schema,
+        dto_class=dto_class,
+        get_id_property_name=get_id_property_name,
+        operation_id=operation_spec.operationId,
+    )
+    dto_instance = _get_dto_instance_from_dto_data(
+        object_schema=body_schema,
+        dto_class=dto_class,
+        dto_data=dto_data,
+        method_spec=operation_spec,
+        dto_cls_name=dto_cls_name,
+    )
+    return RequestData(
+        dto=dto_instance,
+        body_schema=body_schema,
+        parameters=parameters,
+        params=params,
+        headers=headers,
+    )
+
+
+def _get_dto_instance_for_empty_body(
+    dto_class: type[Dto],
+    dto_cls_name: str,
+    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=cls_name,
+            fields=[],
+            bases=(dto_class,),
+        )
+        dto_instance = dto_class()
+    return dto_instance
+
+
+def _get_dto_instance_from_dto_data(
+    object_schema: ObjectSchema,
+    dto_class: type[Dto],
+    dto_data: JSON,
+    method_spec: OperationObject,
+    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(object_schema, dto_data)
+    cls_name = method_spec.operationId if method_spec.operationId else dto_cls_name
+    dto_class_ = make_dataclass(
+        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_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(
+    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[object], Field[object]]] = []
+
+    for key, value in dto_data.items():
+        # 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())  # pylint: disable=invalid-field-call
+            fields.insert(0, (safe_key, type(value), field_))
+        else:
+            field_ = cast(Field[Any], field(default=None))  # pylint: disable=invalid-field-call
+            fields.append((safe_key, type(value), field_))
+    return fields
+
+
+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_request_parameters(
+    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.parameters if method_spec.parameters else []
+    parameter_relations = dto_class.get_parameter_relations()
+    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[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
+        # register the oas_name
+        _ = get_safe_name_for_oas_name(parameter_name)
+        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
+
+        if parameter.schema_ is None:
+            continue
+        value = parameter.schema_.get_valid_value()
+        result[parameter_name] = value
+    return result