diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index 5eaf84b..93882cf 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -1,4 +1,4 @@
-FROM python:3.13-slim-bookworm
+FROM python:3.10-slim-bookworm
# Update the certificates
RUN apt-get update && \
@@ -32,10 +32,9 @@ ENV PATH="$PATH:$POETRY_HOME/bin"
RUN curl -sSL https://install.python-poetry.org | python3 -
RUN poetry self update
-# Configure poetry to not create virtual environments.
-# This is done to force package installation to the global Python install so that users
-# other than the Docker root user have access to the installed packages.
-RUN poetry config virtualenvs.create false
+# Configure poetry to create virtual environments in the project.
+# This is done to be compatible with how uv and PDM set up the venvs.
+RUN poetry config virtualenvs.in-project true
EXPOSE 8888
ENTRYPOINT ["/bin/sh"]
diff --git a/.vscode/example.launch.json b/.vscode/example.launch.json
new file mode 100644
index 0000000..e156bcc
--- /dev/null
+++ b/.vscode/example.launch.json
@@ -0,0 +1,20 @@
+{
+ // Use IntelliSense to learn about possible attributes.
+ // Hover to view descriptions of existing attributes.
+ // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+ "version": "0.2.0",
+ "configurations": [
+ {
+ "name": "Python Debugger: testserver",
+ "type": "debugpy",
+ "request": "launch",
+ "module": "uvicorn",
+ "args": [
+ "testserver:app",
+ "--app-dir=./tests/server",
+ "--host=0.0.0.0",
+ "--port=8000",
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/docs/advanced_use.md b/docs/advanced_use.md
index 710ed74..cee3ada 100644
--- a/docs/advanced_use.md
+++ b/docs/advanced_use.md
@@ -4,7 +4,7 @@
When working with APIs, there are often relations between resources or constraints on values.
The property on one resource may refer to the `id` of another resource.
The value for a certain property may have to be unique within a certain scope.
-Perhaps an endpoint path contains parameters that must match values that are defined outside the API itself.
+Perhaps an url contains parameters that must match values that are defined outside the API itself.
These types of relations and limitations cannot be described / modeled within the openapi document.
To support automatic validation of API endpoints where such relations apply, OpenApiLibCore supports the usage of a custom mappings file.
@@ -42,7 +42,7 @@ from OpenApiLibCore import (
ID_MAPPING = {
- "/myspecialendpoint", "special_thing_id",
+ "/myspecialpath", "special_thing_id",
}
@@ -54,7 +54,7 @@ class MyDtoThatDoesNothing(Dto):
DTO_MAPPING = {
- ("/myspecialendpoint", "post"): MyDtoThatDoesNothing
+ ("/myspecialpath", "post"): MyDtoThatDoesNothing
}
```
@@ -88,16 +88,16 @@ def my_transformer(identifier_name: str) -> str:
ID_MAPPING = {
- "/myspecialendpoint": ("special_thing_id", my_transformer),
+ "/myspecialpath": ("special_thing_id", my_transformer),
}
```
### The DTO_MAPPING
The `DTO_MAPPING` is a dictionary with a tuple as its key and a mappings Dto as its value.
-The tuple must be in the form `("endpoint_from_the_paths_section", "method_supported_by_the_endpoint")`.
-The `endpoint_from_the_paths_section` must be exactly as found in the openapi document.
-The `method_supported_by_the_endpoint` must be one of the methods supported by the endpoint and must be in lowercase.
+The tuple must be in the form `("path_from_the_paths_section", "method_supported_by_the_path")`.
+The `path_from_the_paths_section` must be exactly as found in the openapi document.
+The `method_supported_by_the_path` must be one of the methods supported by the path and must be in lowercase.
## Dto mapping classes
@@ -108,10 +108,10 @@ Each of these classes is designed to handle a relation or constraint commonly se
To explain the different mapping classes, we'll use the following example:
-Imagine we have an API endpoint `/employees` where we can create (`post`) a new Employee resource.
+Imagine we have an API path `/employees` where we can create (`post`) a new Employee resource.
The Employee has a number of required properties; name, employee_number, wagegroup_id, and date_of_birth.
-There is also the the `/wagegroups` endpoint where a Wagegroup resource can be created.
+There is also the the `/wagegroups` path where a Wagegroup resource can be created.
This Wagegroup also has a number of required properties: name and hourly rate.
---
@@ -159,7 +159,7 @@ This `error_code` should be described as one of the `responses` in the openapi d
If an Employee has been added to the system, this Employee refers to the `id` of a Wagegroup for its required `employee_number` property.
-Now let's say there is also the `/wagegroups/${wagegroup_id}` endpoint that supports the `delete` operation.
+Now let's say there is also the `/wagegroups/${wagegroup_id}` path that supports the `delete` operation.
If the Wagegroup refered to the Employee would be deleted, the Employee would be left with an invalid reference for one of its required properties.
To prevent this, an API typically returns an `error_code` when such a `delete` operation is attempted on a resource that is refered to in this fashion.
This `error_code` should be described as one of the `responses` in the openapi document for the `delete` operation of the `/wagegroups/${wagegroup_id}` path.
@@ -314,9 +314,9 @@ To be able to automatically perform endpoint validations, the OpenApiLibCore has
Often, such a `path` contains a reference to a resource id, e.g. `/employees/${employee_id}`.
When such an `id` is needed, the OpenApiLibCore tries to obtain a valid `id` by taking these steps:
-1. Attempt a `post` on the "parent endpoint" and extract the `id` from the response.
-In our example: perform a `post` request on the `/employees` endpoint and get the `id` from the response.
-2. If 1. fails, perform a `get` request on the `/employees` endpoint. It is assumed that this will return a list of Employee objects with an `id`.
+1. Attempt a `post` on the "parent path" and extract the `id` from the response.
+In our example: perform a `post` request on the `/employees` path and get the `id` from the response.
+2. If 1. fails, perform a `get` request on the `/employees` path. It is assumed that this will return a list of Employee objects with an `id`.
One item from the returned list is picked at rondom and its `id` is used.
This mechanism relies on the standard REST structure and patterns.
@@ -339,6 +339,7 @@ DTO_MAPPING = {
("/birthdays/{month}/{date}", "get"): BirthdaysDto
}
```
+> Note: To take a `PathPropertiesConstraint` into use, the related Dto must be mapped to the `get` operation for the `path` in the `DTO_MAPPING` even if no such endpoint exists in the API.
---
@@ -346,7 +347,7 @@ DTO_MAPPING = {
> *Never send this query parameter as part of a request*
Some optional query parameters have a range of valid values that depend on one or more path parameters.
-Since path parameters are part of a url, they cannot be optional or empty so to extend the path parameters with optional parameters, query parameters can be used.
+Since path parameters are part of an url, they cannot be optional or empty so to extend the path parameters with optional parameters, query parameters can be used.
To illustrate this, let's imagine an API where the energy label for a building can be requested: `/energylabel/${zipcode}/${home_number}`.
Some addresses however have an address extension, e.g. 1234AB 42 2.C .
diff --git a/docs/driver.md b/docs/driver.md
index d489c1a..07b934b 100644
--- a/docs/driver.md
+++ b/docs/driver.md
@@ -37,7 +37,7 @@ The OpenAPI Specification (OAS) defines a standard, language-agnostic interface
to RESTful APIs, see https://swagger.io/specification/
The OpenApiDriver module implements a reader class that generates a test case for
-each endpoint, method and response that is defined in an OpenAPI document, typically
+each path, method and response that is defined in an OpenAPI document, typically
an openapi.json or openapi.yaml file.
> Note: OpenApiDriver is designed for APIs based on the OAS v3
@@ -88,13 +88,13 @@ Library OpenApiDriver
Test Template Validate Using Test Endpoint Keyword
*** Test Cases ***
-Test Endpoint for ${method} on ${endpoint} where ${status_code} is expected
+Test Endpoint for ${method} on ${path} where ${status_code} is expected
*** Keywords ***
Validate Using Test Endpoint Keyword
- [Arguments] ${endpoint} ${method} ${status_code}
+ [Arguments] ${path} ${method} ${status_code}
Test Endpoint
- ... endpoint=${endpoint} method=${method} status_code=${status_code}
+ ... path=${path} method=${method} status_code=${status_code}
```
diff --git a/docs/libcore.md b/docs/libcore.md
index a8beed4..4fce562 100644
--- a/docs/libcore.md
+++ b/docs/libcore.md
@@ -76,7 +76,7 @@ recursion in them. See the `recursion_limit` and `recursion_default` parameters.
If the openapi document passes this validation, the next step is trying to do a test
run with a minimal test suite.
-The example below can be used, with `source`, `origin` and 'endpoint' altered to
+The example below can be used, with `source`, `origin` and `path` altered to
fit your situation.
``` robotframework
@@ -87,7 +87,7 @@ Library OpenApiLibCore
*** Test Cases ***
Getting Started
- ${url}= Get Valid Url endpoint=/employees/{employee_id} method=get
+ ${url}= Get Valid Url path=/employees/{employee_id}
```
diff --git a/docs/openapi_libcore.html b/docs/openapi_libcore.html
index 6cceb4a..7dd5bb7 100644
--- a/docs/openapi_libcore.html
+++ b/docs/openapi_libcore.html
@@ -1,1876 +1,410 @@
-
+
-
-
-
Opening library documentation failed
-
- Verify that you have JavaScript enabled in your browser.
- Make sure you are using a modern enough browser . If using Internet Explorer, version 11 is required.
- Check are there messages in your browser's JavaScript error log . Please report the problem if you suspect you have encountered a bug.
-
-
+
{{t "usages"}}
+
+ {{#each usages}}
+ {{this}}
+
-
Opening library documentation failed
-
- Verify that you have JavaScript enabled in your browser.
- Make sure you are using a modern enough browser . If using Internet Explorer, version 11 is required.
- Check are there messages in your browser's JavaScript error log . Please report the problem if you suspect you have encountered a bug.
-
-
+
{{t "usages"}}
+
+ {{#each usages}}
+ {{this}}
+
-0.4.0
+
+1.0.0
<p>Visit the <a href="https://github.com/MarketSquare/robotframework-openapidriver">library page</a> for an introduction and examples.</p>
-
-
+
+
source
-
+
included_paths
-
-
-None
+frozenset()
-
+
ignored_paths
-
-
-None
+frozenset()
-
+
ignored_responses
-
-
-None
+frozenset()
-
+
ignored_testcases
-
-
+
-
-None
+frozenset()
response_validation
@@ -93,16 +81,15 @@
id
-
+
faker_locale
+
-
-None
+
require_body_for_invalid_url
@@ -114,9 +101,23 @@
1
-
+
recursion_default
-
+
+
+
+
+
{}
@@ -142,42 +143,37 @@
None
-
+
cert
+
-
-None
+
-
+
verify_tls
True
-
+
extra_headers
-
-
+
-
-None
+{}
-
+
cookies
-
+
@@ -186,10 +182,10 @@
None
-
+
proxies
-
+
@@ -213,7 +209,7 @@
<h4>ignored_responses</h4>
<p>A list of responses that will be ignored when generating the test cases.</p>
<h4>ignored_testcases</h4>
-<p>A list of specific test cases that, if it would be generated, will be ignored. Specific test cases to ignore must be specified as a <code>Tuple</code> or <code>List</code> of <code>path</code>, <code>method</code> and <code>response</code>.</p>
+<p>A list of specific test cases that, if it would be generated, will be ignored. Specific test cases to ignore must be specified as a <code>tuple</code> or <code>list</code> of <code>path</code>, <code>method</code> and <code>response</code>.</p>
<h4>response_validation</h4>
<p>By default, a <code>WARN</code> is logged when the Response received after a Request does not comply with the schema as defined in the openapi document for the given operation. The following values are supported:</p>
<ul>
@@ -265,7 +261,7 @@
-
+
path
@@ -285,7 +281,7 @@
<p>The keyword calls other keywords to generate the neccesary data to perform the desired operation and validate the response against the openapi document.</p>
Validate that performing the `method` operation on `path` results in a `status_code` response.
-
+
path
@@ -301,7 +297,7 @@
<p>For this keyword to pass, the authorization parameters used to initialize the library should grant insufficient access rights to the target endpoint. > Note: No headers or (json) body are send with the request. For security reasons, the access rights validation should be checked first.</p>
Perform a request for `method` on the `path`, with the provided authorization.
-
+
path
@@ -323,7 +319,7 @@
<p>> Note: Depending on API design, the url may be validated before or after validation of headers, query parameters and / or (json) body. By default, no parameters are send with the request. The <span class="name">require_body_for_invalid_url</span> parameter can be set to <span class="name">True</span> if needed.</p>
Perform a request for the provided 'path' and 'method' where the url for the `path` is invalidated.
-
+
path
@@ -341,15 +337,6 @@
-
-<p>Any value is accepted. No conversion is done.</p>
-
-Any
-
-
-__init__
-
-
<p>Strings <code>TRUE</code>, <code>YES</code>, <code>ON</code> and <code>1</code> are converted to Boolean <code>True</code>, the empty string as well as strings <code>FALSE</code>, <code>NO</code>, <code>OFF</code> and <code>0</code> are converted to Boolean <code>False</code>, and the string <code>NONE</code> is converted to the Python <code>None</code> object. Other strings and other accepted values are passed as-is, allowing keywords to handle them specially if needed. All string comparisons are case-insensitive.</p>
<p>Examples: <code>TRUE</code> (converted to <code>True</code>), <code>off</code> (converted to <code>False</code>), <code>example</code> (used as-is)</p>
@@ -363,6 +350,17 @@
__init__
+
+<p>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 <code>\xHH</code> escape syntax is convenient with bytes having non-printable values.</p>
+<p>Examples: <code>good</code>, <code>hyvรค</code> (same as <code>hyv\xE4</code>), <code>\x00</code> (the null byte)</p>
+
+string
+bytearray
+
+
+__init__
+
+
<p>Strings must be Python <a href="https://docs.python.org/library/stdtypes.html#dict">dictionary</a> literals. They are converted to actual dictionaries using the <a href="https://docs.python.org/library/ast.html#ast.literal_eval">ast.literal_eval</a> function. They can contain any values <code>ast.literal_eval</code> supports, including dictionaries and other containers.</p>
<p>If the type has nested types like <code>dict[str, int]</code>, items are converted to those types automatically. This in new in Robot Framework 6.0.</p>
@@ -375,6 +373,18 @@
__init__
+
+<p>Conversion is done using Python's <a href="https://docs.python.org/library/functions.html#float">float</a> built-in function.</p>
+<p>Starting from RF 4.1, spaces and underscores can be used as visual separators for digit grouping purposes.</p>
+<p>Examples: <code>3.14</code>, <code>2.9979e8</code>, <code>10 000.000 01</code></p>
+
+string
+Real
+
+
+__init__
+
+
<p>Conversion is done using Python's <a href="https://docs.python.org/library/functions.html#int">int</a> built-in function. Floating point numbers are accepted only if they can be represented as integers exactly. For example, <code>1.0</code> is accepted and <code>1.1</code> is not.</p>
<p>Starting from RF 4.1, it is possible to use hexadecimal, octal and binary numbers by prefixing values with <code>0x</code>, <code>0o</code> and <code>0b</code>, respectively.</p>
diff --git a/src/OpenApiDriver/openapidriver.py b/src/OpenApiDriver/openapidriver.py
index 4ca1356..c202085 100644
--- a/src/OpenApiDriver/openapidriver.py
+++ b/src/OpenApiDriver/openapidriver.py
@@ -122,16 +122,22 @@
"""
+from collections.abc import Mapping, MutableMapping
from pathlib import Path
-from typing import Any, Iterable
+from types import MappingProxyType
+from typing import Iterable
-from DataDriver import DataDriver
+from DataDriver.DataDriver import DataDriver
from requests.auth import AuthBase
from requests.cookies import RequestsCookieJar as CookieJar
from robot.api.deco import library
-from OpenApiDriver.openapi_executors import OpenApiExecutors, ValidationLevel
+from OpenApiDriver.openapi_executors import OpenApiExecutors
from OpenApiDriver.openapi_reader import OpenApiReader
+from OpenApiLibCore import ValidationLevel
+from OpenApiLibCore.annotations import JSON
+
+default_str_mapping: Mapping[str, str] = MappingProxyType({})
@library(scope="SUITE", doc_format="ROBOT")
@@ -141,35 +147,33 @@ class OpenApiDriver(OpenApiExecutors, DataDriver):
for an introduction and examples.
"""
- def __init__( # pylint: disable=too-many-arguments, too-many-locals, dangerous-default-value
+ def __init__( # noqa: PLR0913, pylint: disable=dangerous-default-value
self,
source: str,
origin: str = "",
base_path: str = "",
- included_paths: Iterable[str] | None = None, # FIXME: default set?
- ignored_paths: Iterable[str] | None = None, # FIXME: default set?
- ignored_responses: Iterable[int] | None = None, # FIXME: default set?
- ignored_testcases: (
- Iterable[tuple[str, str, int]] | None
- ) = None, # FIXME: default set?
+ 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 = 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] | None = None, # FIXME: default empty string?
+ faker_locale: str | list[str] = "",
require_body_for_invalid_url: bool = False,
recursion_limit: int = 1,
- recursion_default: Any = {},
+ recursion_default: JSON = {},
username: str = "",
password: str = "",
security_token: str = "",
auth: AuthBase | None = None,
- cert: str | tuple[str, str] | None = None, # FIXME: default empty string?
+ cert: str | tuple[str, str] = "",
verify_tls: bool | str = True,
- extra_headers: dict[str, str] | None = None, # FIXME: default empty dict?
- cookies: dict[str, str] | CookieJar | None = None, # FIXME: default empty dict?
- proxies: dict[str, str] | None = None, # FIXME: default empty dict?
+ extra_headers: Mapping[str, str] = default_str_mapping,
+ cookies: MutableMapping[str, str] | CookieJar | None = None,
+ proxies: MutableMapping[str, str] | None = None,
):
"""
== Base parameters ==
diff --git a/src/OpenApiLibCore/__init__.py b/src/OpenApiLibCore/__init__.py
index 94bf7f6..6e188ec 100644
--- a/src/OpenApiLibCore/__init__.py
+++ b/src/OpenApiLibCore/__init__.py
@@ -1,3 +1,4 @@
+# pylint: disable=invalid-name
"""
The OpenApiLibCore package is intended to be used as a dependency for other
Robot Framework libraries that facilitate the testing of OpenAPI / Swagger APIs.
@@ -25,30 +26,30 @@
from OpenApiLibCore.dto_utils import DefaultDto
from OpenApiLibCore.openapi_libcore import (
OpenApiLibCore,
- RequestData,
- RequestValues,
- ValidationLevel,
)
+from OpenApiLibCore.request_data import RequestData, RequestValues
+from OpenApiLibCore.validation import ValidationLevel
from OpenApiLibCore.value_utils import IGNORE
try:
__version__ = version("robotframework-openapi-libcore")
-except Exception: # pragma: no cover
+except Exception: # pragma: no cover pylint: disable=broad-exception-caught
pass
+
__all__ = [
+ "IGNORE",
+ "DefaultDto",
"Dto",
"IdDependency",
"IdReference",
+ "OpenApiLibCore",
"PathPropertiesConstraint",
"PropertyValueConstraint",
- "ResourceRelation",
- "UniquePropertyValueConstraint",
- "DefaultDto",
- "OpenApiLibCore",
"RequestData",
"RequestValues",
+ "ResourceRelation",
+ "UniquePropertyValueConstraint",
"ValidationLevel",
"resolve_schema",
- "IGNORE",
]
diff --git a/src/OpenApiLibCore/annotations.py b/src/OpenApiLibCore/annotations.py
new file mode 100644
index 0000000..170c17f
--- /dev/null
+++ b/src/OpenApiLibCore/annotations.py
@@ -0,0 +1,3 @@
+"""Module holding reusable compound annotations."""
+
+JSON = dict[str, "JSON"] | list["JSON"] | str | bytes | int | float | bool | None
diff --git a/src/OpenApiLibCore/data_generation/__init__.py b/src/OpenApiLibCore/data_generation/__init__.py
new file mode 100644
index 0000000..ea66e00
--- /dev/null
+++ b/src/OpenApiLibCore/data_generation/__init__.py
@@ -0,0 +1,12 @@
+"""
+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",
+]
diff --git a/src/OpenApiLibCore/data_generation/body_data_generation.py b/src/OpenApiLibCore/data_generation/body_data_generation.py
new file mode 100644
index 0000000..74ed586
--- /dev/null
+++ b/src/OpenApiLibCore/data_generation/body_data_generation.py
@@ -0,0 +1,266 @@
+"""
+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.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", []):
+ 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
diff --git a/src/OpenApiLibCore/data_generation/data_generation_core.py b/src/OpenApiLibCore/data_generation/data_generation_core.py
new file mode 100644
index 0000000..ba8d9b9
--- /dev/null
+++ b/src/OpenApiLibCore/data_generation/data_generation_core.py
@@ -0,0 +1,237 @@
+"""
+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.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"]
+ 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
diff --git a/src/OpenApiLibCore/data_invalidation.py b/src/OpenApiLibCore/data_invalidation.py
new file mode 100644
index 0000000..94fc373
--- /dev/null
+++ b/src/OpenApiLibCore/data_invalidation.py
@@ -0,0 +1,281 @@
+"""
+Module holding the functions related to invalidation of valid data (generated
+to make 2xx requests) to support testing for 4xx responses.
+"""
+
+from copy import deepcopy
+from random import choice
+from typing import Any
+
+from requests import Response
+from robot.api import logger
+from robot.libraries.BuiltIn import BuiltIn
+
+from OpenApiLibCore.dto_base import (
+ NOT_SET,
+ Dto,
+ IdReference,
+ PathPropertiesConstraint,
+ PropertyValueConstraint,
+ UniquePropertyValueConstraint,
+ resolve_schema,
+)
+from OpenApiLibCore.request_data import RequestData
+from OpenApiLibCore.value_utils import IGNORE, get_invalid_value, get_valid_value
+
+run_keyword = BuiltIn().run_keyword
+
+
+def get_invalid_json_data(
+ url: str,
+ method: str,
+ status_code: int,
+ request_data: RequestData,
+ 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)
+ ]
+ if not data_relations:
+ if not request_data.dto_schema:
+ raise ValueError(
+ "Failed to invalidate: no data_relations and empty schema."
+ )
+ json_data = request_data.dto.get_invalidated_data(
+ schema=request_data.dto_schema,
+ status_code=status_code,
+ invalid_property_default_code=invalid_property_default_response,
+ )
+ return json_data
+ resource_relation = choice(data_relations)
+ if isinstance(resource_relation, UniquePropertyValueConstraint):
+ json_data = run_keyword(
+ "get_json_data_with_conflict",
+ url,
+ method,
+ request_data.dto,
+ status_code,
+ )
+ elif isinstance(resource_relation, IdReference):
+ run_keyword("ensure_in_use", url, resource_relation)
+ json_data = request_data.dto.as_dict()
+ else:
+ json_data = request_data.dto.get_invalidated_data(
+ schema=request_data.dto_schema,
+ status_code=status_code,
+ invalid_property_default_code=invalid_property_default_response,
+ )
+ return json_data
+
+
+def get_invalidated_parameters(
+ status_code: int, request_data: RequestData, invalid_property_default_response: int
+) -> tuple[dict[str, Any], dict[str, str]]:
+ if not request_data.parameters:
+ raise ValueError("No params or headers to invalidate.")
+
+ # ensure the status_code can be triggered
+ relations = request_data.dto.get_parameter_relations_for_error_code(status_code)
+ relations_for_status_code = [
+ r
+ for r in relations
+ if isinstance(r, PropertyValueConstraint)
+ and (status_code in (r.error_code, r.invalid_value_error_code))
+ ]
+ parameters_to_ignore = {
+ r.property_name
+ for r in relations_for_status_code
+ if r.invalid_value_error_code == status_code and r.invalid_value == IGNORE
+ }
+ relation_property_names = {r.property_name for r in relations_for_status_code}
+ if not relation_property_names:
+ if status_code != invalid_property_default_response:
+ raise ValueError(f"No relations to cause status_code {status_code} found.")
+
+ # ensure we're not modifying mutable properties
+ params = deepcopy(request_data.params)
+ headers = deepcopy(request_data.headers)
+
+ if status_code == invalid_property_default_response:
+ # take the params and headers that can be invalidated based on data type
+ # and expand the set with properties that can be invalided by relations
+ parameter_names = set(request_data.params_that_can_be_invalidated).union(
+ request_data.headers_that_can_be_invalidated
+ )
+ parameter_names.update(relation_property_names)
+ if not parameter_names:
+ raise ValueError(
+ "None of the query parameters and headers can be invalidated."
+ )
+ else:
+ # non-default status_codes can only be the result of a Relation
+ parameter_names = relation_property_names
+
+ # 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]
+ additional_relation_property_names = {
+ n for n in relation_property_names if n not in request_data_parameter_names
+ }
+ if additional_relation_property_names:
+ logger.warn(
+ f"get_parameter_relations_for_error_code yielded properties that are "
+ f"not defined in the schema: {additional_relation_property_names}\n"
+ f"These properties will be ignored for parameter invalidation."
+ )
+ parameter_names = parameter_names - additional_relation_property_names
+
+ if not parameter_names:
+ raise ValueError(
+ f"No parameter can be changed to cause status_code {status_code}."
+ )
+
+ parameter_names = parameter_names - parameters_to_ignore
+ parameter_to_invalidate = choice(tuple(parameter_names))
+
+ # check for invalid parameters in the provided request_data
+ try:
+ [parameter_data] = [
+ data
+ for data in request_data.parameters
+ if data["name"] == parameter_to_invalidate
+ ]
+ except Exception:
+ raise ValueError(
+ f"{parameter_to_invalidate} not found in provided parameters."
+ ) from None
+
+ # get the invalid_value for the chosen parameter
+ try:
+ [invalid_value_for_error_code] = [
+ r.invalid_value
+ for r in relations_for_status_code
+ if r.property_name == parameter_to_invalidate
+ and r.invalid_value_error_code == status_code
+ ]
+ except ValueError:
+ invalid_value_for_error_code = NOT_SET
+
+ # get the constraint values if available for the chosen parameter
+ try:
+ [values_from_constraint] = [
+ r.values
+ for r in relations_for_status_code
+ if r.property_name == parameter_to_invalidate
+ ]
+ except ValueError:
+ values_from_constraint = []
+
+ # if the parameter was not provided, add it to params / headers
+ params, headers = ensure_parameter_in_parameters(
+ parameter_to_invalidate=parameter_to_invalidate,
+ params=params,
+ headers=headers,
+ parameter_data=parameter_data,
+ values_from_constraint=values_from_constraint,
+ )
+
+ # determine the invalid_value
+ if invalid_value_for_error_code != NOT_SET:
+ invalid_value = invalid_value_for_error_code
+ else:
+ if parameter_to_invalidate in params.keys():
+ valid_value = params[parameter_to_invalidate]
+ else:
+ valid_value = headers[parameter_to_invalidate]
+
+ value_schema = resolve_schema(parameter_data["schema"])
+ invalid_value = get_invalid_value(
+ value_schema=value_schema,
+ current_value=valid_value,
+ values_from_constraint=values_from_constraint,
+ )
+ logger.debug(f"{parameter_to_invalidate} changed to {invalid_value}")
+
+ # update the params / headers and return
+ if parameter_to_invalidate in params.keys():
+ params[parameter_to_invalidate] = invalid_value
+ else:
+ headers[parameter_to_invalidate] = str(invalid_value)
+ return params, headers
+
+
+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]]:
+ """
+ Returns the params, headers tuple with parameter_to_invalidate with a valid
+ value to params or headers if not originally present.
+ """
+ if (
+ parameter_to_invalidate not in params.keys()
+ and parameter_to_invalidate not in headers.keys()
+ ):
+ 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)
+ if (
+ parameter_data["in"] == "query"
+ and parameter_to_invalidate not in params.keys()
+ ):
+ params[parameter_to_invalidate] = valid_value
+ if (
+ parameter_data["in"] == "header"
+ and parameter_to_invalidate not in headers.keys()
+ ):
+ headers[parameter_to_invalidate] = str(valid_value)
+ return params, headers
+
+
+def get_json_data_with_conflict(
+ url: str, base_url: str, method: str, dto: Dto, conflict_status_code: int
+) -> dict[str, Any]:
+ method = method.lower()
+ json_data = dto.as_dict()
+ unique_property_value_constraints = [
+ r for r in dto.get_relations() if isinstance(r, UniquePropertyValueConstraint)
+ ]
+ for relation in unique_property_value_constraints:
+ json_data[relation.property_name] = relation.value
+ # create a new resource that the original request will conflict with
+ if method in ["patch", "put"]:
+ post_url_parts = url.split("/")[:-1]
+ post_url = "/".join(post_url_parts)
+ # the PATCH or PUT may use a different dto than required for POST
+ # so a valid POST dto must be constructed
+ path = post_url.replace(base_url, "")
+ request_data: RequestData = run_keyword("get_request_data", path, "post")
+ post_json = request_data.dto.as_dict()
+ for key in post_json.keys():
+ if key in json_data:
+ post_json[key] = json_data.get(key)
+ else:
+ post_url = url
+ post_json = json_data
+ path = post_url.replace(base_url, "")
+ request_data = run_keyword("get_request_data", path, "post")
+
+ response: Response = run_keyword(
+ "authorized_request",
+ post_url,
+ "post",
+ request_data.params,
+ request_data.headers,
+ post_json,
+ )
+ # conflicting resource may already exist
+ assert response.ok or response.status_code == conflict_status_code, (
+ f"get_json_data_with_conflict received {response.status_code}: {response.json()}"
+ )
+ return json_data
+ raise ValueError(
+ f"No UniquePropertyValueConstraint in the get_relations list on dto {dto}."
+ )
diff --git a/src/OpenApiLibCore/dto_base.py b/src/OpenApiLibCore/dto_base.py
index a617ded..814ed80 100644
--- a/src/OpenApiLibCore/dto_base.py
+++ b/src/OpenApiLibCore/dto_base.py
@@ -7,14 +7,13 @@
from abc import ABC
from copy import deepcopy
from dataclasses import dataclass, fields
-from logging import getLogger
from random import choice, shuffle
from typing import Any
from uuid import uuid4
-from OpenApiLibCore import value_utils
+from robot.api import logger
-logger = getLogger(__name__)
+from OpenApiLibCore import value_utils
NOT_SET = object()
SENTINEL = object()
@@ -86,7 +85,7 @@ def merge_schemas(first: dict[str, Any], second: dict[str, Any]) -> dict[str, An
return merged_schema
-class ResourceRelation(ABC): # pylint: disable=too-few-public-methods
+class ResourceRelation(ABC):
"""ABC for all resource relations or restrictions within the API."""
property_name: str
@@ -95,7 +94,7 @@ class ResourceRelation(ABC): # pylint: disable=too-few-public-methods
@dataclass
class PathPropertiesConstraint(ResourceRelation):
- """The resolved path for the endpoint."""
+ """The value to be used as the ``path`` for related requests."""
path: str
property_name: str = "id"
@@ -231,12 +230,12 @@ def get_invalidated_data(
if isinstance(r, IdDependency) and r.property_name == property_name
]
if id_dependencies:
- invalid_value = uuid4().hex
+ invalid_id = uuid4().hex
logger.debug(
f"Breaking IdDependency for status_code {status_code}: replacing "
- f"{properties[property_name]} with {invalid_value}"
+ f"{properties[property_name]} with {invalid_id}"
)
- properties[property_name] = invalid_value
+ properties[property_name] = invalid_id
return properties
invalid_value_from_constraint = [
@@ -297,11 +296,11 @@ def get_invalidated_data(
)
properties[property_name] = invalid_value
logger.debug(
- f"Property {property_name} changed to {invalid_value} (received from "
+ f"Property {property_name} changed to {invalid_value!r} (received from "
f"get_invalid_value)"
)
return properties
- logger.warning("get_invalidated_data returned unchanged properties")
+ logger.warn("get_invalidated_data returned unchanged properties")
return properties # pragma: no cover
def as_dict(self) -> dict[Any, Any]:
diff --git a/src/OpenApiLibCore/dto_utils.py b/src/OpenApiLibCore/dto_utils.py
index 84e5b7d..3f8368e 100644
--- a/src/OpenApiLibCore/dto_utils.py
+++ b/src/OpenApiLibCore/dto_utils.py
@@ -2,12 +2,12 @@
from dataclasses import dataclass
from importlib import import_module
-from logging import getLogger
-from typing import Callable, Type
+from typing import Any, Callable, Type, overload
-from OpenApiLibCore.dto_base import Dto
+from robot.api import logger
-logger = getLogger(__name__)
+from OpenApiLibCore.dto_base import Dto
+from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
@dataclass
@@ -23,8 +23,11 @@ class DefaultDto(Dto):
"""A default Dto that can be instantiated."""
-# pylint: disable=invalid-name, too-few-public-methods
-class get_dto_class:
+def get_dto_class(mappings_module_name: str) -> GetDtoClassType:
+ return GetDtoClass(mappings_module_name=mappings_module_name)
+
+
+class GetDtoClass:
"""Callable class to return Dtos from user-implemented mappings file."""
def __init__(self, mappings_module_name: str) -> None:
@@ -38,16 +41,19 @@ def __init__(self, mappings_module_name: str) -> None:
logger.error(f"DTO_MAPPING was not imported: {exception}")
self.dto_mapping = {}
- def __call__(self, endpoint: str, method: str) -> Type[Dto]:
+ def __call__(self, path: str, method: str) -> Type[Dto]:
try:
- return self.dto_mapping[(endpoint, method.lower())]
+ return self.dto_mapping[(path, method.lower())]
except KeyError:
- logger.debug(f"No Dto mapping for {endpoint} {method}.")
+ logger.debug(f"No Dto mapping for {path} {method}.")
return DefaultDto
-# pylint: disable=invalid-name, too-few-public-methods
-class get_id_property_name:
+def get_id_property_name(mappings_module_name: str) -> GetIdPropertyNameType:
+ return GetIdPropertyName(mappings_module_name=mappings_module_name)
+
+
+class GetIdPropertyName:
"""
Callable class to return the name of the property that uniquely identifies
the resource from user-implemented mappings file.
@@ -58,8 +64,7 @@ def __init__(self, mappings_module_name: str) -> None:
mappings_module = import_module(mappings_module_name)
self.id_mapping: dict[
str,
- str
- | tuple[str, tuple[Callable[[str | int | float], str | int | float]]],
+ str | tuple[str, Callable[[str], str] | Callable[[int], int]],
] = mappings_module.ID_MAPPING
except (ImportError, AttributeError, ValueError) as exception:
if mappings_module_name != "no mapping":
@@ -67,13 +72,26 @@ def __init__(self, mappings_module_name: str) -> None:
self.id_mapping = {}
def __call__(
- self, endpoint: str
- ) -> str | tuple[str, tuple[Callable[[str | int | float], str | int | float]]]:
+ self, path: str
+ ) -> tuple[str, Callable[[str], str] | Callable[[int], int]]:
try:
- return self.id_mapping[endpoint]
+ value_or_mapping = self.id_mapping[path]
+ if isinstance(value_or_mapping, str):
+ return (value_or_mapping, dummy_transformer)
+ return value_or_mapping
except KeyError:
default_id_name = DEFAULT_ID_PROPERTY_NAME.id_property_name
- logger.debug(
- f"No id mapping for {endpoint} ('{default_id_name}' will be used)"
- )
- return default_id_name
+ logger.debug(f"No id mapping for {path} ('{default_id_name}' will be used)")
+ return (default_id_name, dummy_transformer)
+
+
+@overload
+def dummy_transformer(valid_id: str) -> str: ...
+
+
+@overload
+def dummy_transformer(valid_id: int) -> int: ...
+
+
+def dummy_transformer(valid_id: Any) -> Any:
+ return valid_id
diff --git a/src/OpenApiLibCore/oas_cache.py b/src/OpenApiLibCore/oas_cache.py
index 474bd40..a9c4d24 100644
--- a/src/OpenApiLibCore/oas_cache.py
+++ b/src/OpenApiLibCore/oas_cache.py
@@ -1,17 +1,18 @@
-from typing import Callable
+"""Module holding the (global) parser cache."""
+
+from dataclasses import dataclass
from openapi_core import Spec
-from openapi_core.contrib.requests import (
- RequestsOpenAPIRequest,
- RequestsOpenAPIResponse,
-)
from prance import ResolvingParser
-PARSER_CACHE: dict[
- str,
- tuple[
- ResolvingParser,
- Spec,
- Callable[[RequestsOpenAPIRequest, RequestsOpenAPIResponse], None],
- ],
-] = {}
+from OpenApiLibCore.protocols import ResponseValidatorType
+
+
+@dataclass
+class CachedParser:
+ parser: ResolvingParser
+ validation_spec: Spec
+ response_validator: ResponseValidatorType
+
+
+PARSER_CACHE: dict[str, CachedParser] = {}
diff --git a/src/OpenApiLibCore/openapi_libcore.libspec b/src/OpenApiLibCore/openapi_libcore.libspec
index 5db5ae2..5601f88 100644
--- a/src/OpenApiLibCore/openapi_libcore.libspec
+++ b/src/OpenApiLibCore/openapi_libcore.libspec
@@ -1,13 +1,13 @@
-
-0.4.0
+
+1.0.0
<p>Main class providing the keywords and core logic to interact with an OpenAPI server.</p>
<p>Visit the <a href="https://github.com/MarketSquare/robotframework-openapi-libcore">library page</a> for an introduction.</p>
-
-
+
+
source
id
-
+
faker_locale
+
-
-None
+
require_body_for_invalid_url
@@ -71,9 +70,23 @@
1
-
+
recursion_default
-
+
+
+
+
+
{}
@@ -99,42 +112,37 @@
None
-
+
cert
+
-
-None
+
-
+
verify_tls
True
-
+
extra_headers
-
-
+
-
-None
+{}
-
+
cookies
-
+
@@ -143,10 +151,10 @@
None
-
+
proxies
-
+
@@ -161,7 +169,7 @@
<h4>origin</h4>
<p>The server (and port) of the target server. E.g. <code>https://localhost:8000</code></p>
<h4>base_path</h4>
-<p>The routing between <code>origin</code> and the endpoints as found in the <code>paths</code> section in the openapi document. E.g. <code>/petshop/v2</code>.</p>
+<p>The routing between <code>origin</code> and the paths as found in the <code>paths</code> section in the openapi document. E.g. <code>/petshop/v2</code>.</p>
<h3>Test case execution</h3>
<h4>response_validation</h4>
<p>By default, a <code>WARN</code> is logged when the Response received after a Request does not comply with the schema as defined in the openapi document for the given operation. The following values are supported:</p>
@@ -214,8 +222,39 @@
-
-
+
+
+
+href
+
+
+referenced_resource
+
+
+
+
+
+
+
+
+
+
+<p>Attempt to GET the resource referenced by the <span class="name">href</span> and validate it's equal to the provided <span class="name">referenced_resource</span> object / dictionary.</p>
+Attempt to GET the resource referenced by the `href` and validate it's equal to the provided `referenced_resource` object / dictionary.
+
+
+
url
method
-
+
params
-
+
@@ -235,10 +274,10 @@
None
-
+
headers
-
+
@@ -246,43 +285,18 @@
None
-
+
json_data
-
-
-
-
-
-
-
-
-
-
-
+
-
+
-
-
None
-
+
data
+
None
-
+
files
+
None
@@ -307,7 +327,7 @@
<p>> Note: provided username / password or auth objects take precedence over token based security</p>
Perform a request using the security token or authentication set in the library.
-
+
url
@@ -321,20 +341,20 @@
<p>Ensure that the (right-most) <span class="name">id</span> of the resource referenced by the <span class="name">url</span> is used by the resource defined by the <span class="name">resource_relation</span>.</p>
Ensure that the (right-most) `id` of the resource referenced by the `url` is used by the resource defined by the `resource_relation`.
-
+
url
-
+
<p>Perform a GET request on the <span class="name">url</span> and return the list of resource <span class="name">ids</span> from the response.</p>
Perform a GET request on the `url` and return the list of resource `ids` from the response.
-
+
url
@@ -353,15 +373,29 @@
-
+
+
+
+
+
+
<p>Return <span class="name">json_data</span> based on the <span class="name">dto</span> on the <span class="name">request_data</span> that will cause the provided <span class="name">status_code</span> for the <span class="name">method</span> operation on the <span class="name">url</span>.</p>
<p>> Note: applicable UniquePropertyValueConstraint and IdReference Relations are considered before changes to <span class="name">json_data</span> are made.</p>
Return `json_data` based on the `dto` on the `request_data` that will cause the provided `status_code` for the `method` operation on the `url`.
-
+
status_code
@@ -372,12 +406,26 @@
-
-
+
+
+
+
+
+
+
-
+
@@ -385,8 +433,8 @@
<p>Returns a version of <span class="name">params, headers</span> as present on <span class="name">request_data</span> that has been modified to cause the provided <span class="name">status_code</span>.</p>
Returns a version of `params, headers` as present on `request_data` that has been modified to cause the provided `status_code`.
-
-
+
+
valid_url
-
-method
-
expected_status_code
404
-
-
-<p>Return an url with all the path parameters in the <span class="name">valid_url</span> replaced by a random UUID if no PathPropertiesConstraint is mapped for the <a href="#type-Path" class="name">path</a>, <span class="name">method</span> and <span class="name">expected_status_code</span>. If a PathPropertiesConstraint is mapped, the <span class="name">invalid_value</span> is returned.</p>
+<p>Return an url with all the path parameters in the <span class="name">valid_url</span> replaced by a random UUID if no PathPropertiesConstraint is mapped for the <span class="name">"get"</span> operation on the mapped <a href="#type-Path" class="name">path</a> and <span class="name">expected_status_code</span>. If a PathPropertiesConstraint is mapped, the <span class="name">invalid_value</span> is returned.</p>
<p>Raises ValueError if the valid_url cannot be invalidated.</p>
-Return an url with all the path parameters in the `valid_url` replaced by a random UUID if no PathPropertiesConstraint is mapped for the `path`, `method` and `expected_status_code`. If a PathPropertiesConstraint is mapped, the `invalid_value` is returned.
+Return an url with all the path parameters in the `valid_url` replaced by a random UUID if no PathPropertiesConstraint is mapped for the `"get"` operation on the mapped `path` and `expected_status_code`. If a PathPropertiesConstraint is mapped, the `invalid_value` is returned.
-
-
-
+
+
+
schema
-
+
+
+
+
+
+
-
+
dto_class
-
-
+
-
operation_id
@@ -440,16 +491,24 @@
-
+
+
+
+
-<p>Generate a valid (json-compatible) dict for all the <span class="name">dto_class</span> properties.</p>
-Generate a valid (json-compatible) dict for all the `dto_class` properties.
+<p>Generate valid (json-compatible) data for the <span class="name">dto_class</span>.</p>
+Generate valid (json-compatible) data for the `dto_class`.
-
+
url
@@ -468,14 +527,28 @@
-
+
+
+
+
+
+
<p>Return <span class="name">json_data</span> based on the <span class="name">UniquePropertyValueConstraint</span> that must be returned by the <span class="name">get_relations</span> implementation on the <span class="name">dto</span> for the given <span class="name">conflict_status_code</span>.</p>
Return `json_data` based on the `UniquePropertyValueConstraint` that must be returned by the `get_relations` implementation on the `dto` for the given `conflict_status_code`.
-
+
url
@@ -483,13 +556,13 @@
<p>Return the endpoint as found in the <span class="name">paths</span> section based on the given <span class="name">url</span>.</p>
-Return the endpoint as found in the `paths` section based on the given `url`.
+<p>Return the path as found in the <span class="name">paths</span> section based on the given <span class="name">url</span>.</p>
+Return the path as found in the `paths` section based on the given `url`.
-
-
-
-endpoint
+
+
+
+path
@@ -501,14 +574,10 @@
<p>Return an object with valid request data for body, headers and query params.</p>
Return an object with valid request data for body, headers and query params.
-
-
-
-endpoint
-
-
-method
+
+
+
+path
@@ -517,29 +586,25 @@
<p>Support keyword that returns the <span class="name">id</span> for an existing resource at <span class="name">endpoint</span>.</p>
-<p>To prevent resource conflicts with other test cases, a new resource is created (POST) if possible.</p>
-Support keyword that returns the `id` for an existing resource at `endpoint`.
+<p>Support keyword that returns the <span class="name">id</span> for an existing resource at <a href="#type-Path" class="name">path</a>.</p>
+<p>To prevent resource conflicts with other test cases, a new resource is created (by a POST operation) if possible.</p>
+Support keyword that returns the `id` for an existing resource at `path`.
-
-
-
-endpoint
-
-
-method
+
+
+
+path
<p>This keyword returns a valid url for the given <span class="name">endpoint</span> and <span class="name">method</span>.</p>
-<p>If the <span class="name">endpoint</span> contains path parameters the Get Valid Id For Endpoint keyword will be executed to retrieve valid ids for the path parameters.</p>
-<p>> Note: if valid ids cannot be retrieved within the scope of the API, the <span class="name">PathPropertiesConstraint</span> Relation can be used. More information can be found <a href="https://marketsquare.github.io/robotframework-openapi-libcore/advanced_use.html">here</a>.</p>
-This keyword returns a valid url for the given `endpoint` and `method`.
+<p>This keyword returns a valid url for the given <a href="#type-Path" class="name">path</a>.</p>
+<p>If the <a href="#type-Path" class="name">path</a> contains path parameters the Get Valid Id For Path keyword will be executed to retrieve valid ids for the path parameters.</p>
+<p>> Note: if valid ids cannot be retrieved within the scope of the API, the <span class="name">PathPropertiesConstraint</span> Relation can be used. More information can be found <a href="https://marketsquare.github.io/robotframework-openapitools/advanced_use.html">here</a>.</p>
+This keyword returns a valid url for the given `path`.
-
-
+
+
path
request_values
-
+
original_data
-
-
+
-
-None
+{}
<p>This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates, for <span class="name">DELETE</span> operations, whether the target resource was indeed deleted (OK response) or not (error responses).</p>
This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates, for `DELETE` operations, whether the target resource was indeed deleted (OK response) or not (error responses).
-
+
auth
@@ -578,7 +640,7 @@
<p>After calling this keyword, subsequent requests will use the provided <span class="name">auth</span> instance.</p>
Set the `auth` used for authentication after the library is imported.
-
+
username
@@ -593,11 +655,11 @@
<p>After calling this keyword, subsequent requests will use the provided credentials.</p>
Set the `username` and `password` used for basic authentication after the library is imported.
-
-
-
+
+
+
extra_headers
-
+
@@ -607,7 +669,7 @@
<p>After calling this keyword, subsequent requests will use the provided <span class="name">extra_headers</span>.</p>
Set the `extra_headers` used in requests after the library is imported.
-
+
origin
@@ -619,7 +681,7 @@
<p>In combination with OpenApiLibCore, the <span class="name">origin</span> can be used at any point to target another server that hosts an API that complies to the same OAS.</p>
Set the `origin` after the library is imported.
-
+
security_token
@@ -630,28 +692,56 @@
<p>After calling this keyword, subsequent requests will use the provided token.</p>
Set the `security_token` after the library is imported.
-
-
-
+
+
+
resource
-
+
+
+
+
+
+
-
+
schema
-
+
+
+
+
+
+
<p>Validate that the <span class="name">resource</span> does not contain any properties that are not defined in the <span class="name">schema_properties</span>.</p>
Validate that the `resource` does not contain any properties that are not defined in the `schema_properties`.
-
-
+
+
path
response
-
+
original_data
-
-
+
-
-None
+{}
<p>Validate the <span class="name">response</span> by performing the following validations:</p>
<ul>
-<li>validate the <span class="name">response</span> against the openapi schema for the <span class="name">endpoint</span></li>
+<li>validate the <span class="name">response</span> against the openapi schema for the <a href="#type-Path" class="name">path</a></li>
<li>validate that the response does not contain extra properties</li>
<li>validate that a href, if present, refers to the correct resource</li>
<li>validate that the value for a property that is in the response is equal to the property value that was send</li>
<li>validate that no <span class="name">original_data</span> is preserved when performing a PUT operation</li>
<li>validate that a PATCH operation only updates the provided properties</li>
</ul>
-Validate the `response` by performing the following validations: - validate the `response` against the openapi schema for the `endpoint` - validate that the response does not contain extra properties - validate that a href, if present, refers to the correct resource - validate that the value for a property that is in the response is equal to the property value that was send - validate that no `original_data` is preserved when performing a PUT operation - validate that a PATCH operation only updates the provided properties
+Validate the `response` by performing the following validations: - validate the `response` against the openapi schema for the `path` - validate that the response does not contain extra properties - validate that a href, if present, refers to the correct resource - validate that the value for a property that is in the response is equal to the property value that was send - validate that no `original_data` is preserved when performing a PUT operation - validate that a PATCH operation only updates the provided properties
+
+
+
+
+request
+
+
+response
+
+
+<p>Validate the <span class="name">response</span> for a given <span class="name">request</span> against the OpenAPI Spec that is loaded during library initialization.</p>
+Validate the `response` for a given `request` against the OpenAPI Spec that is loaded during library initialization.
-
-
+
+
response
-
+
original_data
-
-
+
-
-None
+{}
<p>Validate that each property that was send that is in the response has the value that was send. In case a PATCH request, validate that only the properties that were patched have changed and that other properties are still at their pre-patch values.</p>
@@ -712,16 +810,7 @@
Any
-__init__
Authorized Request
-Get Invalid Json Data
-Get Invalidated Parameters
-Get Json Data For Dto Class
-Get Json Data With Conflict
-Perform Validated Request
-Validate Resource Properties
-Validate Response
-Validate Send Response
@@ -735,7 +824,31 @@
__init__
+Assert Href To Resource Is Valid
Authorized Request
+Get Invalid Json Data
+Get Invalidated Parameters
+Get Json Data For Dto Class
+Get Json Data With Conflict
+Validate Resource Properties
+
+
+
+<p>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 <code>\xHH</code> escape syntax is convenient with bytes having non-printable values.</p>
+<p>Examples: <code>good</code>, <code>hyvรค</code> (same as <code>hyv\xE4</code>), <code>\x00</code> (the null byte)</p>
+
+string
+bytearray
+
+
+__init__
+Assert Href To Resource Is Valid
+Authorized Request
+Get Invalid Json Data
+Get Invalidated Parameters
+Get Json Data For Dto Class
+Get Json Data With Conflict
+Validate Resource Properties
@@ -748,6 +861,7 @@
__init__
+Assert Href To Resource Is Valid
Authorized Request
Get Invalid Json Data
Get Invalidated Parameters
@@ -769,8 +883,15 @@
Real
+__init__
+Assert Href To Resource Is Valid
Authorized Request
-Get Valid Id For Endpoint
+Get Invalid Json Data
+Get Invalidated Parameters
+Get Json Data For Dto Class
+Get Json Data With Conflict
+Get Valid Id For Path
+Validate Resource Properties
@@ -784,13 +905,16 @@
__init__
+Assert Href To Resource Is Valid
Authorized Request
Get Invalid Json Data
Get Invalidated Parameters
Get Invalidated Url
+Get Json Data For Dto Class
Get Json Data With Conflict
-Get Valid Id For Endpoint
+Get Valid Id For Path
Perform Validated Request
+Validate Resource Properties
@@ -803,8 +927,14 @@
__init__
+Assert Href To Resource Is Valid
Authorized Request
Get Ids From Url
+Get Invalid Json Data
+Get Invalidated Parameters
+Get Json Data For Dto Class
+Get Json Data With Conflict
+Validate Resource Properties
@@ -814,12 +944,13 @@
__init__
+Assert Href To Resource Is Valid
Authorized Request
-Get Invalidated Url
+Get Invalid Json Data
+Get Invalidated Parameters
Get Json Data For Dto Class
-Perform Validated Request
-Validate Response
-Validate Send Response
+Get Json Data With Conflict
+Validate Resource Properties
@@ -840,6 +971,7 @@
__init__
+Assert Href To Resource Is Valid
Authorized Request
Ensure In Use
Get Ids From Url
@@ -848,9 +980,9 @@
Get Invalidated Url
Get Json Data For Dto Class
Get Json Data With Conflict
-Get Parameterized Endpoint From Url
+Get Parameterized Path From Url
Get Request Data
-Get Valid Id For Endpoint
+Get Valid Id For Path
Get Valid Url
Perform Validated Request
Set Basic Auth
diff --git a/src/OpenApiLibCore/openapi_libcore.py b/src/OpenApiLibCore/openapi_libcore.py
index eedd25c..0a29d07 100644
--- a/src/OpenApiLibCore/openapi_libcore.py
+++ b/src/OpenApiLibCore/openapi_libcore.py
@@ -75,7 +75,7 @@
If the openapi document passes this validation, the next step is trying to do a test
run with a minimal test suite.
-The example below can be used, with `source`, `origin` and 'endpoint' altered to
+The example below can be used, with `source`, `origin` and `path` altered to
fit your situation.
``` robotframework
@@ -86,7 +86,7 @@
*** Test Cases ***
Getting Started
- ${url}= Get Valid Url endpoint=/employees/{employee_id} method=get
+ ${url}= Get Valid Url path=/employees/{employee_id}
```
@@ -119,331 +119,55 @@
"""
import json as _json
-import re
import sys
+from collections.abc import Mapping, MutableMapping
from copy import deepcopy
-from dataclasses import Field, dataclass, field, make_dataclass
-from enum import Enum
from functools import cached_property
-from itertools import zip_longest
-from logging import getLogger
from pathlib import Path
-from random import choice, sample
-from typing import Any, Callable, Generator
-from uuid import uuid4
+from types import MappingProxyType
+from typing import Any, Generator
from openapi_core import Config, OpenAPI, Spec
from openapi_core.contrib.requests import (
RequestsOpenAPIRequest,
RequestsOpenAPIResponse,
)
-from openapi_core.exceptions import OpenAPIError
-from openapi_core.templating.paths.exceptions import ServerNotFound
from openapi_core.validation.exceptions import ValidationError
-from openapi_core.validation.response.exceptions import ResponseValidationError
-from openapi_core.validation.schemas.exceptions import InvalidSchemaValue
from prance import ResolvingParser
from prance.util.url import ResolutionError
from requests import Response, Session
from requests.auth import AuthBase, HTTPBasicAuth
from requests.cookies import RequestsCookieJar as CookieJar
+from robot.api import logger
from robot.api.deco import keyword, library
-from robot.api.exceptions import Failure
+from robot.api.exceptions import FatalError
from robot.libraries.BuiltIn import BuiltIn
-from OpenApiLibCore import value_utils
-from OpenApiLibCore.dto_base import (
- NOT_SET,
- Dto,
- IdDependency,
- IdReference,
- PathPropertiesConstraint,
- PropertyValueConstraint,
- ResourceRelation,
- UniquePropertyValueConstraint,
- resolve_schema,
-)
+import OpenApiLibCore.data_generation as _data_generation
+import OpenApiLibCore.data_invalidation as di
+import OpenApiLibCore.path_functions as pf
+import OpenApiLibCore.path_invalidation as pi
+import OpenApiLibCore.resource_relations as rr
+import OpenApiLibCore.validation as val
+from OpenApiLibCore.annotations import JSON
+from OpenApiLibCore.dto_base import Dto, IdReference
from OpenApiLibCore.dto_utils import (
DEFAULT_ID_PROPERTY_NAME,
- DefaultDto,
get_dto_class,
get_id_property_name,
)
-from OpenApiLibCore.oas_cache import PARSER_CACHE
-from OpenApiLibCore.value_utils import FAKE, IGNORE, JSON
+from OpenApiLibCore.oas_cache import PARSER_CACHE, CachedParser
+from OpenApiLibCore.protocols import ResponseValidatorType
+from OpenApiLibCore.request_data import RequestData, RequestValues
+from OpenApiLibCore.value_utils import FAKE
run_keyword = BuiltIn().run_keyword
-
-logger = getLogger(__name__)
-
-
-class ValidationLevel(str, Enum):
- """The available levels for the response_validation parameter."""
-
- DISABLED = "DISABLED"
- INFO = "INFO"
- WARN = "WARN"
- STRICT = "STRICT"
-
-
-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
-
-
-@dataclass
-class RequestValues:
- """Helper class to hold parameter values needed to make a request."""
-
- url: str
- method: str
- params: dict[str, Any] | None # FIXME: default empty dict?
- headers: dict[str, str] | None # FIXME: default empty dict?
- json_data: dict[str, Any] | None # FIXME: default empty dict?
-
-
-@dataclass
-class RequestData:
- """Helper class to manage parameters used when making requests."""
-
- dto: Dto | DefaultDto = field(default_factory=DefaultDto)
- dto_schema: dict[str, Any] = field(default_factory=dict)
- parameters: list[dict[str, Any]] = field(default_factory=list)
- params: dict[str, Any] = field(default_factory=dict)
- headers: dict[str, Any] = field(default_factory=dict)
- has_body: bool = True
-
- def __post_init__(self) -> None:
- # prevent modification by reference
- self.dto_schema = deepcopy(self.dto_schema)
- self.parameters = deepcopy(self.parameters)
- self.params = deepcopy(self.params)
- self.headers = deepcopy(self.headers)
-
- @property
- def has_optional_properties(self) -> bool:
- """Whether or not the dto data (json data) contains optional properties."""
-
- def is_required_property(property_name: str) -> bool:
- return property_name in self.dto_schema.get("required", [])
-
- properties = (self.dto.as_dict()).keys()
- return not all(map(is_required_property, properties))
-
- @property
- def has_optional_params(self) -> bool:
- """Whether or not any of the query parameters are optional."""
-
- def is_optional_param(query_param: str) -> bool:
- optional_params = [
- p.get("name")
- for p in self.parameters
- if p.get("in") == "query" and not p.get("required")
- ]
- return query_param in optional_params
-
- return any(map(is_optional_param, self.params))
-
- @cached_property
- def params_that_can_be_invalidated(self) -> set[str]:
- """
- The query parameters that can be invalidated by violating data
- restrictions, data type or by not providing them in a request.
- """
- result = set()
- params = [h for h in self.parameters if h.get("in") == "query"]
- for param in params:
- # required params can be omitted to invalidate a request
- if param["required"]:
- result.add(param["name"])
- continue
-
- schema = resolve_schema(param["schema"])
- if schema.get("type", None):
- param_types = [schema]
- else:
- param_types = schema["types"]
- for param_type in param_types:
- # any basic non-string type except "null" can be invalidated by
- # replacing it with a string
- if param_type["type"] not in ["string", "array", "object", "null"]:
- result.add(param["name"])
- continue
- # enums, strings and arrays with boundaries can be invalidated
- if set(param_type.keys()).intersection(
- {
- "enum",
- "minLength",
- "maxLength",
- "minItems",
- "maxItems",
- }
- ):
- result.add(param["name"])
- continue
- # an array of basic non-string type can be invalidated by replacing the
- # items in the array with strings
- if param_type["type"] == "array" and param_type["items"][
- "type"
- ] not in [
- "string",
- "array",
- "object",
- "null",
- ]:
- result.add(param["name"])
- return result
-
- @property
- def has_optional_headers(self) -> bool:
- """Whether or not any of the headers are optional."""
-
- def is_optional_header(header: str) -> bool:
- optional_headers = [
- p.get("name")
- for p in self.parameters
- if p.get("in") == "header" and not p.get("required")
- ]
- return header in optional_headers
-
- return any(map(is_optional_header, self.headers))
-
- @cached_property
- def headers_that_can_be_invalidated(self) -> set[str]:
- """
- The header parameters that can be invalidated by violating data
- restrictions or by not providing them in a request.
- """
- result = set()
- headers = [h for h in self.parameters if h.get("in") == "header"]
- for header in headers:
- # required headers can be omitted to invalidate a request
- if header["required"]:
- result.add(header["name"])
- continue
-
- schema = resolve_schema(header["schema"])
- if schema.get("type", None):
- header_types = [schema]
- else:
- header_types = schema["types"]
- for header_type in header_types:
- # any basic non-string type except "null" can be invalidated by
- # replacing it with a string
- if header_type["type"] not in ["string", "array", "object", "null"]:
- result.add(header["name"])
- continue
- # enums, strings and arrays with boundaries can be invalidated
- if set(header_type.keys()).intersection(
- {
- "enum",
- "minLength",
- "maxLength",
- "minItems",
- "maxItems",
- }
- ):
- result.add(header["name"])
- continue
- # an array of basic non-string type can be invalidated by replacing the
- # items in the array with strings
- if header_type["type"] == "array" and header_type["items"][
- "type"
- ] not in [
- "string",
- "array",
- "object",
- "null",
- ]:
- result.add(header["name"])
- return result
-
- def get_required_properties_dict(self) -> dict[str, Any]:
- """Get the json-compatible dto data containing only the required properties."""
- relations = self.dto.get_relations()
- mandatory_properties = [
- relation.property_name
- for relation in relations
- if getattr(relation, "treat_as_mandatory", False)
- ]
- required_properties: list[str] = self.dto_schema.get("required", [])
- required_properties.extend(mandatory_properties)
-
- required_properties_dict: dict[str, Any] = {}
- for key, value in (self.dto.as_dict()).items():
- if key in required_properties:
- required_properties_dict[key] = value
- return required_properties_dict
-
- def get_minimal_body_dict(self) -> dict[str, Any]:
- required_properties_dict = self.get_required_properties_dict()
-
- min_properties = self.dto_schema.get("minProperties", 0)
- number_of_optional_properties_to_add = min_properties - len(
- required_properties_dict
- )
-
- if number_of_optional_properties_to_add < 1:
- return required_properties_dict
-
- optional_properties_dict = {
- k: v
- for k, v in self.dto.as_dict().items()
- if k not in required_properties_dict
- }
- optional_properties_to_keep = sample(
- sorted(optional_properties_dict), number_of_optional_properties_to_add
- )
- optional_properties_dict = {
- k: v
- for k, v in optional_properties_dict.items()
- if k in optional_properties_to_keep
- }
-
- return {**required_properties_dict, **optional_properties_dict}
-
- def get_required_params(self) -> dict[str, str]:
- """Get the params dict containing only the required query parameters."""
- relations = self.dto.get_parameter_relations()
- mandatory_properties = [
- relation.property_name
- for relation in relations
- if getattr(relation, "treat_as_mandatory", False)
- ]
- mandatory_parameters = [p for p in mandatory_properties if p in self.parameters]
-
- required_parameters = [
- p.get("name") for p in self.parameters if p.get("required")
- ]
- required_parameters.extend(mandatory_parameters)
- return {k: v for k, v in self.params.items() if k in required_parameters}
-
- def get_required_headers(self) -> dict[str, str]:
- """Get the headers dict containing only the required headers."""
- relations = self.dto.get_parameter_relations()
- mandatory_properties = [
- relation.property_name
- for relation in relations
- if getattr(relation, "treat_as_mandatory", False)
- ]
- mandatory_parameters = [p for p in mandatory_properties if p in self.parameters]
-
- required_parameters = [
- p.get("name") for p in self.parameters if p.get("required")
- ]
- required_parameters.extend(mandatory_parameters)
- return {k: v for k, v in self.headers.items() if k in required_parameters}
+default_str_mapping: Mapping[str, str] = MappingProxyType({})
+default_any_mapping: Mapping[str, object] = MappingProxyType({})
@library(scope="SUITE", doc_format="ROBOT")
-class OpenApiLibCore: # pylint: disable=too-many-instance-attributes
+class OpenApiLibCore: # pylint: disable=too-many-public-methods
"""
Main class providing the keywords and core logic to interact with an OpenAPI server.
@@ -451,12 +175,12 @@ class OpenApiLibCore: # pylint: disable=too-many-instance-attributes
for an introduction.
"""
- def __init__( # pylint: disable=too-many-arguments, too-many-locals, dangerous-default-value
+ def __init__( # noqa: PLR0913, pylint: disable=dangerous-default-value
self,
source: str,
origin: str = "",
base_path: str = "",
- response_validation: ValidationLevel = ValidationLevel.WARN,
+ response_validation: val.ValidationLevel = val.ValidationLevel.WARN,
disable_server_validation: bool = True,
mappings_path: str | Path = "",
invalid_property_default_response: int = 422,
@@ -464,16 +188,16 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals, dangerous-
faker_locale: str | list[str] = "",
require_body_for_invalid_url: bool = False,
recursion_limit: int = 1,
- recursion_default: Any = {},
+ recursion_default: JSON = {},
username: str = "",
password: str = "",
security_token: str = "",
auth: AuthBase | None = None,
- cert: str | tuple[str, str] | None = None,
+ cert: str | tuple[str, str] = "",
verify_tls: bool | str = True,
- extra_headers: dict[str, str] = {},
- cookies: dict[str, str] | CookieJar = {},
- proxies: dict[str, str] = {},
+ extra_headers: Mapping[str, str] = default_str_mapping,
+ cookies: MutableMapping[str, str] | CookieJar | None = None,
+ proxies: MutableMapping[str, str] | None = None,
) -> None:
"""
== Base parameters ==
@@ -485,7 +209,7 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals, dangerous-
The server (and port) of the target server. E.g. ``https://localhost:8000``
=== base_path ===
- The routing between ``origin`` and the endpoints as found in the ``paths``
+ The routing between ``origin`` and the paths as found in the ``paths``
section in the openapi document.
E.g. ``/petshop/v2``.
@@ -601,18 +325,18 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals, dangerous-
self.response_validation = response_validation
self.disable_server_validation = disable_server_validation
self._recursion_limit = recursion_limit
- self._recursion_default = recursion_default
+ self._recursion_default = deepcopy(recursion_default)
self.session = Session()
- # only username and password, security_token or auth object should be provided
+ # Only username and password, security_token or auth object should be provided
# if multiple are provided, username and password take precedence
self.security_token = security_token
self.auth = auth
if username:
self.auth = HTTPBasicAuth(username, password)
- # Robot Framework does not allow users to create tuples and requests
- # does not accept lists, so perform the conversion here
- if isinstance(cert, list):
- cert = tuple(cert)
+ # Requests only allows a string or a tuple[str, str], so ensure cert is a tuple
+ # if the passed argument is not a string.
+ if not isinstance(cert, str):
+ cert = (cert[0], cert[1])
self.cert = cert
self.verify = verify_tls
self.extra_headers = extra_headers
@@ -622,11 +346,9 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals, dangerous-
if mappings_path and str(mappings_path) != ".":
mappings_path = Path(mappings_path)
if not mappings_path.is_file():
- logger.warning(
- f"mappings_path '{mappings_path}' is not a Python module."
- )
- # intermediate variable to ensure path.append is possible so we'll never
- # path.pop a location that we didn't append
+ logger.warn(f"mappings_path '{mappings_path}' is not a Python module.")
+ # Intermediate variable to ensure path.append is possible so we'll never
+ # path.pop a location that we didn't append.
mappings_folder = str(mappings_path.parent)
sys.path.append(mappings_folder)
mappings_module_name = mappings_path.stem
@@ -649,10 +371,7 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals, dangerous-
DEFAULT_ID_PROPERTY_NAME.id_property_name = default_id_property_name
self._server_validation_warning_logged = False
- @property
- def origin(self) -> str:
- return self._origin
-
+ # region: library configuration keywords
@keyword
def set_origin(self, origin: str) -> None:
"""
@@ -708,1018 +427,197 @@ def set_extra_headers(self, extra_headers: dict[str, str]) -> None:
"""
self.extra_headers = extra_headers
- @property
- def base_url(self) -> str:
- return f"{self.origin}{self._base_path}"
-
- @cached_property
- def validation_spec(self) -> Spec:
- _, validation_spec, _ = self._load_specs_and_validator()
- return validation_spec
-
- @property
- def openapi_spec(self) -> dict[str, Any]:
- """Return a deepcopy of the parsed openapi document."""
- # protect the parsed openapi spec from being mutated by reference
- return deepcopy(self._openapi_spec)
-
- @cached_property
- def _openapi_spec(self) -> dict[str, Any]:
- parser, _, _ = self._load_specs_and_validator()
- return parser.specification
+ # endregion
+ # region: data generation keywords
+ @keyword
+ def get_request_data(self, path: str, method: str) -> RequestData:
+ """Return an object with valid request data for body, headers and query params."""
+ return _data_generation.get_request_data(
+ path=path,
+ method=method,
+ get_dto_class=self.get_dto_class,
+ get_id_property_name=self.get_id_property_name,
+ openapi_spec=self.openapi_spec,
+ )
- @cached_property
- def response_validator(
+ @keyword
+ def get_json_data_for_dto_class(
self,
- ) -> Callable[[RequestsOpenAPIRequest, RequestsOpenAPIResponse], None]:
- _, _, response_validator = self._load_specs_and_validator()
- return response_validator
-
- def _get_json_types_from_spec(self, spec: dict[str, Any]) -> set[str]:
- json_types: set[str] = set(self._get_json_types(spec))
- return {json_type for json_type in json_types if json_type is not None}
-
- def _get_json_types(self, item: Any) -> Generator[str, None, None]:
- if isinstance(item, dict):
- content_dict = item.get("content")
- if content_dict is None:
- for value in item.values():
- yield from self._get_json_types(value)
-
- else:
- for content_type in content_dict:
- if "json" in content_type:
- content_type_without_charset, _, _ = content_type.partition(";")
- yield content_type_without_charset
-
- if isinstance(item, list):
- for list_item in item:
- yield from self._get_json_types(list_item)
+ schema: dict[str, JSON],
+ dto_class: type[Dto],
+ operation_id: str = "",
+ ) -> JSON:
+ """
+ Generate valid (json-compatible) data for the `dto_class`.
+ """
+ return _data_generation.get_json_data_for_dto_class(
+ schema=schema,
+ dto_class=dto_class,
+ get_id_property_name=self.get_id_property_name,
+ operation_id=operation_id,
+ )
- def _load_specs_and_validator(
+ @keyword
+ def get_invalid_json_data(
self,
- ) -> tuple[
- ResolvingParser,
- Spec,
- Callable[[RequestsOpenAPIRequest, RequestsOpenAPIResponse], None],
- ]:
- try:
-
- def recursion_limit_handler(
- limit: int, refstring: str, recursions: Any
- ) -> Any:
- return self._recursion_default
-
- # Since parsing of the OAS and creating the Spec can take a long time,
- # they are cached. This is done by storing them in an imported module that
- # will have a global scope due to how the Python import system works. This
- # ensures that in a Suite of Suites where multiple Suites use the same
- # `source`, that OAS is only parsed / loaded once.
- parser, validation_spec, response_validator = PARSER_CACHE.get(
- self._source, (None, None, None)
- )
-
- if parser is None:
- parser = ResolvingParser(
- self._source,
- backend="openapi-spec-validator",
- recursion_limit=self._recursion_limit,
- recursion_limit_handler=recursion_limit_handler,
- )
-
- if parser.specification is None: # pragma: no cover
- BuiltIn().fatal_error(
- "Source was loaded, but no specification was present after parsing."
- )
-
- validation_spec = Spec.from_dict(parser.specification)
-
- json_types_from_spec: set[str] = self._get_json_types_from_spec(
- parser.specification
- )
- extra_deserializers = {
- json_type: _json.loads for json_type in json_types_from_spec
- }
- config = Config(extra_media_type_deserializers=extra_deserializers)
- openapi = OpenAPI(spec=validation_spec, config=config)
- response_validator = openapi.validate_response
-
- PARSER_CACHE[self._source] = (
- parser,
- validation_spec,
- response_validator,
- )
-
- return parser, validation_spec, response_validator
+ url: str,
+ method: str,
+ status_code: int,
+ request_data: RequestData,
+ ) -> dict[str, JSON]:
+ """
+ Return `json_data` based on the `dto` on the `request_data` that will cause
+ the provided `status_code` for the `method` operation on the `url`.
- except ResolutionError as exception:
- BuiltIn().fatal_error(
- f"ResolutionError while trying to load openapi spec: {exception}"
- )
- except ValidationError as exception:
- BuiltIn().fatal_error(
- f"ValidationError while trying to load openapi spec: {exception}"
- )
+ > Note: applicable UniquePropertyValueConstraint and IdReference Relations are
+ considered before changes to `json_data` are made.
+ """
+ return di.get_invalid_json_data(
+ url=url,
+ method=method,
+ status_code=status_code,
+ request_data=request_data,
+ invalid_property_default_response=self.invalid_property_default_response,
+ )
- def validate_response_vs_spec(
- self, request: RequestsOpenAPIRequest, response: RequestsOpenAPIResponse
- ) -> None:
+ @keyword
+ def get_invalidated_parameters(
+ self,
+ status_code: int,
+ request_data: RequestData,
+ ) -> tuple[dict[str, JSON], dict[str, str]]:
"""
- Validate the reponse for a given request against the OpenAPI Spec that is
- loaded during library initialization.
+ Returns a version of `params, headers` as present on `request_data` that has
+ been modified to cause the provided `status_code`.
"""
- self.response_validator(request=request, response=response)
+ return di.get_invalidated_parameters(
+ status_code=status_code,
+ request_data=request_data,
+ invalid_property_default_response=self.invalid_property_default_response,
+ )
- def read_paths(self) -> dict[str, Any]:
- return self.openapi_spec["paths"]
+ @keyword
+ def get_json_data_with_conflict(
+ self, url: str, method: str, dto: Dto, conflict_status_code: int
+ ) -> dict[str, JSON]:
+ """
+ Return `json_data` based on the `UniquePropertyValueConstraint` that must be
+ returned by the `get_relations` implementation on the `dto` for the given
+ `conflict_status_code`.
+ """
+ return di.get_json_data_with_conflict(
+ url=url,
+ base_url=self.base_url,
+ method=method,
+ dto=dto,
+ conflict_status_code=conflict_status_code,
+ )
+ # endregion
+ # region: path-related keywords
@keyword
- def get_valid_url(self, endpoint: str, method: str) -> str:
+ def get_valid_url(self, path: str) -> str:
"""
- This keyword returns a valid url for the given `endpoint` and `method`.
+ This keyword returns a valid url for the given `path`.
- If the `endpoint` contains path parameters the Get Valid Id For Endpoint
+ If the `path` contains path parameters the Get Valid Id For Path
keyword will be executed to retrieve valid ids for the path parameters.
> Note: if valid ids cannot be retrieved within the scope of the API, the
`PathPropertiesConstraint` Relation can be used. More information can be found
- [https://marketsquare.github.io/robotframework-openapi-libcore/advanced_use.html | here].
+ [https://marketsquare.github.io/robotframework-openapitools/advanced_use.html | here].
"""
- method = method.lower()
- try:
- # endpoint can be partially resolved or provided by a PathPropertiesConstraint
- parametrized_endpoint = self.get_parametrized_endpoint(endpoint=endpoint)
- _ = self.openapi_spec["paths"][parametrized_endpoint]
- except KeyError:
- raise ValueError(
- f"{endpoint} not found in paths section of the OpenAPI document."
- ) from None
- dto_class = self.get_dto_class(endpoint=endpoint, method=method)
- relations = dto_class.get_relations()
- paths = [p.path for p in relations if isinstance(p, PathPropertiesConstraint)]
- if paths:
- url = f"{self.base_url}{choice(paths)}"
- return url
- endpoint_parts = list(endpoint.split("/"))
- for index, part in enumerate(endpoint_parts):
- if part.startswith("{") and part.endswith("}"):
- type_endpoint_parts = endpoint_parts[slice(index)]
- type_endpoint = "/".join(type_endpoint_parts)
- existing_id: str | int | float = run_keyword(
- "get_valid_id_for_endpoint", type_endpoint, method
- )
- endpoint_parts[index] = str(existing_id)
- resolved_endpoint = "/".join(endpoint_parts)
- url = f"{self.base_url}{resolved_endpoint}"
- return url
+ return pf.get_valid_url(
+ path=path,
+ base_url=self.base_url,
+ get_dto_class=self.get_dto_class,
+ openapi_spec=self.openapi_spec,
+ )
@keyword
- def get_valid_id_for_endpoint(
- self, endpoint: str, method: str
- ) -> str | int | float:
+ def get_valid_id_for_path(self, path: str) -> str | int | float:
"""
- Support keyword that returns the `id` for an existing resource at `endpoint`.
+ Support keyword that returns the `id` for an existing resource at `path`.
To prevent resource conflicts with other test cases, a new resource is created
- (POST) if possible.
+ (by a POST operation) if possible.
"""
-
- def dummy_transformer(valid_id: str | int | float) -> str | int | float:
- return valid_id
-
- method = method.lower()
- url: str = run_keyword("get_valid_url", endpoint, method)
- # Try to create a new resource to prevent conflicts caused by
- # operations performed on the same resource by other test cases
- request_data = self.get_request_data(endpoint=endpoint, method="post")
-
- response: Response = run_keyword(
- "authorized_request",
- url,
- "post",
- request_data.get_required_params(),
- request_data.get_required_headers(),
- request_data.get_required_properties_dict(),
+ return pf.get_valid_id_for_path(
+ path=path, get_id_property_name=self.get_id_property_name
)
- # determine the id property name for this path and whether or not a transformer is used
- mapping = self.get_id_property_name(endpoint=endpoint)
- if isinstance(mapping, str):
- id_property = mapping
- # set the transformer to a dummy callable that returns the original value so
- # the transformer can be applied on any returned id
- id_transformer = dummy_transformer
- else:
- id_property, id_transformer = mapping
-
- if not response.ok:
- # If a new resource cannot be created using POST, try to retrieve a
- # valid id using a GET request.
- try:
- valid_id = choice(run_keyword("get_ids_from_url", url))
- return id_transformer(valid_id)
- except Exception as exception:
- raise AssertionError(
- f"Failed to get a valid id using GET on {url}"
- ) from exception
-
- response_data = response.json()
- if prepared_body := response.request.body:
- if isinstance(prepared_body, bytes):
- send_json = _json.loads(prepared_body.decode("UTF-8"))
- else:
- send_json = _json.loads(prepared_body)
- else:
- send_json = None
-
- # no support for retrieving an id from an array returned on a POST request
- if isinstance(response_data, list):
- raise NotImplementedError(
- f"Unexpected response body for POST request: expected an object but "
- f"received an array ({response_data})"
- )
-
- # POST on /resource_type/{id}/array_item/ will return the updated {id} resource
- # instead of a newly created resource. In this case, the send_json must be
- # in the array of the 'array_item' property on {id}
- send_path: str = response.request.path_url
- response_href: str = response_data.get("href", "")
- if response_href and (send_path not in response_href) and send_json:
- try:
- property_to_check = send_path.replace(response_href, "")[1:]
- item_list: list[dict[str, Any]] = response_data[property_to_check]
- # Use the (mandatory) id to get the POSTed resource from the list
- [valid_id] = [
- item[id_property]
- for item in item_list
- if item[id_property] == send_json[id_property]
- ]
- except Exception as exception:
- raise AssertionError(
- f"Failed to get a valid id from {response_href}"
- ) from exception
- else:
- try:
- valid_id = response_data[id_property]
- except KeyError:
- raise AssertionError(
- f"Failed to get a valid id from {response_data}"
- ) from None
- return id_transformer(valid_id)
-
@keyword
- def get_ids_from_url(self, url: str) -> list[str]:
+ def get_parameterized_path_from_url(self, url: str) -> str:
"""
- Perform a GET request on the `url` and return the list of resource
- `ids` from the response.
+ Return the path as found in the `paths` section based on the given `url`.
"""
- endpoint = self.get_parameterized_endpoint_from_url(url)
- request_data = self.get_request_data(endpoint=endpoint, method="get")
- response = run_keyword(
- "authorized_request",
- url,
- "get",
- request_data.get_required_params(),
- request_data.get_required_headers(),
- )
- response.raise_for_status()
- response_data: dict[str, Any] | list[dict[str, Any]] = response.json()
-
- # determine the property name to use
- mapping = self.get_id_property_name(endpoint=endpoint)
- if isinstance(mapping, str):
- id_property = mapping
- else:
- id_property, _ = mapping
-
- if isinstance(response_data, list):
- valid_ids: list[str] = [item[id_property] for item in response_data]
- return valid_ids
- # if the response is an object (dict), check if it's hal+json
- if embedded := response_data.get("_embedded"):
- # there should be 1 item in the dict that has a value that's a list
- for value in embedded.values():
- if isinstance(value, list):
- valid_ids = [item[id_property] for item in value]
- return valid_ids
- if (valid_id := response_data.get(id_property)) is not None:
- return [valid_id]
- valid_ids = [item[id_property] for item in response_data["items"]]
- return valid_ids
-
- @keyword
- def get_request_data(self, endpoint: str, method: str) -> RequestData:
- """Return an object with valid request data for body, headers and query params."""
- method = method.lower()
- dto_cls_name = self._get_dto_cls_name(endpoint=endpoint, method=method)
- # The endpoint can contain already resolved Ids that have to be matched
- # against the parametrized endpoints in the paths section.
- spec_endpoint = self.get_parametrized_endpoint(endpoint)
- dto_class = self.get_dto_class(endpoint=spec_endpoint, method=method)
- try:
- method_spec = self.openapi_spec["paths"][spec_endpoint][method]
- except KeyError:
- logger.info(
- f"method '{method}' not supported on '{spec_endpoint}, using empty spec."
- )
- method_spec = {}
-
- parameters, params, headers = self.get_request_parameters(
- dto_class=dto_class, method_spec=method_spec
- )
- if (body_spec := method_spec.get("requestBody", None)) is None:
- 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 RequestData(
- dto=dto_instance,
- parameters=parameters,
- params=params,
- headers=headers,
- has_body=False,
- )
- content_schema = resolve_schema(self.get_content_schema(body_spec))
- headers.update({"content-type": self.get_content_type(body_spec)})
- dto_data = self.get_json_data_for_dto_class(
- schema=content_schema,
- dto_class=dto_class,
- operation_id=method_spec.get("operationId", ""),
- )
- if dto_data is None:
- dto_instance = DefaultDto()
- else:
- fields = self.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()}
- dto_instance = dto_class(**dto_data)
- return RequestData(
- dto=dto_instance,
- dto_schema=content_schema,
- parameters=parameters,
- params=params,
- headers=headers,
- )
-
- @staticmethod
- def _get_dto_cls_name(endpoint: str, method: str) -> str:
- method = method.capitalize()
- path = endpoint.translate({ord(i): None for i in "{}"})
+ path = url.replace(self.base_url, "")
path_parts = path.split("/")
- path_parts = [p.capitalize() for p in path_parts]
- result = "".join([method, *path_parts])
- return result
-
- @staticmethod
- def get_fields_from_dto_data(
- content_schema: dict[str, Any], dto_data: dict[str, Any]
- ) -> list[str | tuple[str, type[Any]] | tuple[str, type[Any], Field[Any]]]:
- """Get a dataclasses fields list based on the content_schema and dto_data."""
- fields: list[
- str | tuple[str, type[Any]] | 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
- fields.insert(0, (safe_key, type(value), field(metadata=metadata)))
- else:
- fields.append((safe_key, type(value), field(default=None, metadata=metadata))) # type: ignore[arg-type]
- return fields
-
- def get_request_parameters(
- self, 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 = self.get_parameter_data(query_params, parameter_relations)
- headers = self.get_parameter_data(header_params, parameter_relations)
- return parameters, params, headers
-
- @classmethod
- def get_content_schema(cls, body_spec: dict[str, Any]) -> dict[str, Any]:
- """Get the content schema from the requestBody spec."""
- content_type = cls.get_content_type(body_spec)
- content_schema = body_spec["content"][content_type]["schema"]
- return resolve_schema(content_schema)
-
- @staticmethod
- 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}'."
+ # first part will be '' since a path starts with /
+ path_parts.pop(0)
+ parameterized_path = pf.get_parametrized_path(
+ path=path, openapi_spec=self.openapi_spec
)
-
- def get_parametrized_endpoint(self, endpoint: str) -> str:
- """
- Get the parametrized endpoint as found in the `paths` section of the openapi
- document from a (partially) resolved endpoint.
- """
-
- def match_parts(parts: list[str], spec_parts: list[str]) -> bool:
- for part, spec_part in zip_longest(parts, spec_parts, fillvalue="Filler"):
- if part == "Filler" or spec_part == "Filler":
- return False
- if part != spec_part and not spec_part.startswith("{"):
- return False
- return True
-
- endpoint_parts = endpoint.split("/")
- # if the last part is empty, the path has a trailing `/` that
- # should be ignored during matching
- if endpoint_parts[-1] == "":
- _ = endpoint_parts.pop(-1)
-
- spec_endpoints: list[str] = {**self.openapi_spec}["paths"].keys()
-
- candidates: list[str] = []
-
- for spec_endpoint in spec_endpoints:
- spec_endpoint_parts = spec_endpoint.split("/")
- # ignore trailing `/` the same way as for endpoint_parts
- if spec_endpoint_parts[-1] == "":
- _ = spec_endpoint_parts.pop(-1)
- if match_parts(endpoint_parts, spec_endpoint_parts):
- candidates.append(spec_endpoint)
-
- if not candidates:
- raise ValueError(
- f"{endpoint} not found in paths section of the OpenAPI document."
- )
-
- if len(candidates) == 1:
- return candidates[0]
- # Multiple matches can happen in APIs with overloaded endpoints, e.g.
- # /users/me
- # /users/${user_id}
- # In this case, find the closest (or exact) match
- exact_match = [c for c in candidates if c == endpoint]
- if exact_match:
- return exact_match[0]
- # TODO: Implement a decision mechanism when real-world examples become available
- # In the face of ambiguity, refuse the temptation to guess.
- raise ValueError(f"{endpoint} matched to multiple paths: {candidates}")
-
- @staticmethod
- 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"]
- 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 = value_utils.get_valid_value(parameter_schema)
- result[parameter_name] = value
- return result
+ return parameterized_path
@keyword
- def get_json_data_for_dto_class(
- self,
- schema: dict[str, Any],
- dto_class: Dto | type[Dto],
- operation_id: str = "",
- ) -> dict[str, Any]:
+ def get_ids_from_url(self, url: str) -> list[str]:
"""
- Generate a valid (json-compatible) dict for all the `dto_class` properties.
+ Perform a GET request on the `url` and return the list of resource
+ `ids` from the response.
"""
-
- def get_constrained_values(property_name: str) -> list[Any]:
- 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(
- property_name: str, operation_id: str
- ) -> 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 = self.get_valid_id_for_endpoint(
- endpoint=id_get_path, method="get"
- )
- logger.debug(f"get_dependent_id for {id_get_path} returned {valid_id}")
- return valid_id
-
- json_data: dict[str, Any] = {}
-
- property_names = []
- for property_name in schema.get("properties", []):
- if constrained_values := get_constrained_values(property_name):
- # do not add properties that are configured to be ignored
- if IGNORE in constrained_values:
- 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
-
- for property_name in property_names:
- properties_schema = schema["properties"][property_name]
-
- property_type = properties_schema.get("type")
- if property_type is None:
- property_types = properties_schema.get("types")
- if property_types is None:
- if properties_schema.get("properties") is not None:
- nested_data = self.get_json_data_for_dto_class(
- schema=properties_schema,
- dto_class=DefaultDto,
- )
- json_data[property_name] = nested_data
- continue
- selected_type_schema = choice(property_types)
- property_type = selected_type_schema["type"]
- if properties_schema.get("readOnly", False):
- continue
- if constrained_values := get_constrained_values(property_name):
- json_data[property_name] = choice(constrained_values)
- continue
- if (
- dependent_id := get_dependent_id(
- property_name=property_name, operation_id=operation_id
- )
- ) is not None:
- json_data[property_name] = dependent_id
- continue
- if property_type == "object":
- object_data = self.get_json_data_for_dto_class(
- schema=properties_schema,
- dto_class=DefaultDto,
- operation_id="",
- )
- json_data[property_name] = object_data
- continue
- if property_type == "array":
- array_data = self.get_json_data_for_dto_class(
- schema=properties_schema["items"],
- dto_class=DefaultDto,
- operation_id=operation_id,
- )
- json_data[property_name] = [array_data]
- continue
- json_data[property_name] = value_utils.get_valid_value(properties_schema)
-
- return json_data
+ return pf.get_ids_from_url(
+ url=url, get_id_property_name=self.get_id_property_name
+ )
@keyword
def get_invalidated_url(
self,
valid_url: str,
path: str = "",
- method: str = "",
expected_status_code: int = 404,
) -> str:
"""
Return an url with all the path parameters in the `valid_url` replaced by a
- random UUID if no PathPropertiesConstraint is mapped for the `path`, `method`
- and `expected_status_code`.
+ random UUID if no PathPropertiesConstraint is mapped for the `"get"` operation
+ on the mapped `path` and `expected_status_code`.
If a PathPropertiesConstraint is mapped, the `invalid_value` is returned.
Raises ValueError if the valid_url cannot be invalidated.
"""
- dto_class = self.get_dto_class(endpoint=path, method=method)
- relations = dto_class.get_relations()
- paths = [
- p.invalid_value
- for p in relations
- if isinstance(p, PathPropertiesConstraint)
- and p.invalid_value_error_code == expected_status_code
- ]
- if paths:
- url = f"{self.base_url}{choice(paths)}"
- return url
- parameterized_endpoint = self.get_parameterized_endpoint_from_url(valid_url)
- parameterized_url = self.base_url + parameterized_endpoint
- valid_url_parts = list(reversed(valid_url.split("/")))
- parameterized_parts = reversed(parameterized_url.split("/"))
- for index, (parameterized_part, _) in enumerate(
- zip(parameterized_parts, valid_url_parts)
- ):
- if parameterized_part.startswith("{") and parameterized_part.endswith("}"):
- valid_url_parts[index] = uuid4().hex
- valid_url_parts.reverse()
- invalid_url = "/".join(valid_url_parts)
- return invalid_url
- raise ValueError(f"{parameterized_endpoint} could not be invalidated.")
-
- @keyword
- def get_parameterized_endpoint_from_url(self, url: str) -> str:
- """
- Return the endpoint as found in the `paths` section based on the given `url`.
- """
- endpoint = url.replace(self.base_url, "")
- endpoint_parts = endpoint.split("/")
- # first part will be '' since an endpoint starts with /
- endpoint_parts.pop(0)
- parameterized_endpoint = self.get_parametrized_endpoint(endpoint=endpoint)
- return parameterized_endpoint
-
- @keyword
- def get_invalid_json_data(
- self,
- url: str,
- method: str,
- status_code: int,
- request_data: RequestData,
- ) -> dict[str, Any]:
- """
- Return `json_data` based on the `dto` on the `request_data` that will cause
- the provided `status_code` for the `method` operation on the `url`.
-
- > Note: applicable UniquePropertyValueConstraint and IdReference Relations are
- considered before changes to `json_data` are made.
- """
- 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)
- ]
- if not data_relations:
- if not request_data.dto_schema:
- raise ValueError(
- "Failed to invalidate: no data_relations and empty schema."
- )
- json_data = request_data.dto.get_invalidated_data(
- schema=request_data.dto_schema,
- status_code=status_code,
- invalid_property_default_code=self.invalid_property_default_response,
- )
- return json_data
- resource_relation = choice(data_relations)
- if isinstance(resource_relation, UniquePropertyValueConstraint):
- json_data = run_keyword(
- "get_json_data_with_conflict",
- url,
- method,
- request_data.dto,
- status_code,
- )
- elif isinstance(resource_relation, IdReference):
- run_keyword("ensure_in_use", url, resource_relation)
- json_data = request_data.dto.as_dict()
- else:
- json_data = request_data.dto.get_invalidated_data(
- schema=request_data.dto_schema,
- status_code=status_code,
- invalid_property_default_code=self.invalid_property_default_response,
- )
- return json_data
-
- @keyword
- def get_invalidated_parameters(
- self,
- status_code: int,
- request_data: RequestData,
- ) -> tuple[dict[str, Any], dict[str, str]]:
- """
- Returns a version of `params, headers` as present on `request_data` that has
- been modified to cause the provided `status_code`.
- """
- if not request_data.parameters:
- raise ValueError("No params or headers to invalidate.")
-
- # ensure the status_code can be triggered
- relations = request_data.dto.get_parameter_relations_for_error_code(status_code)
- relations_for_status_code = [
- r
- for r in relations
- if isinstance(r, PropertyValueConstraint)
- and (
- r.error_code == status_code or r.invalid_value_error_code == status_code
- )
- ]
- parameters_to_ignore = {
- r.property_name
- for r in relations_for_status_code
- if r.invalid_value_error_code == status_code and r.invalid_value == IGNORE
- }
- relation_property_names = {r.property_name for r in relations_for_status_code}
- if not relation_property_names:
- if status_code != self.invalid_property_default_response:
- raise ValueError(
- f"No relations to cause status_code {status_code} found."
- )
-
- # ensure we're not modifying mutable properties
- params = deepcopy(request_data.params)
- headers = deepcopy(request_data.headers)
-
- if status_code == self.invalid_property_default_response:
- # take the params and headers that can be invalidated based on data type
- # and expand the set with properties that can be invalided by relations
- parameter_names = set(request_data.params_that_can_be_invalidated).union(
- request_data.headers_that_can_be_invalidated
- )
- parameter_names.update(relation_property_names)
- if not parameter_names:
- raise ValueError(
- "None of the query parameters and headers can be invalidated."
- )
- else:
- # non-default status_codes can only be the result of a Relation
- parameter_names = relation_property_names
-
- # 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]
- additional_relation_property_names = {
- n for n in relation_property_names if n not in request_data_parameter_names
- }
- if additional_relation_property_names:
- logger.warning(
- f"get_parameter_relations_for_error_code yielded properties that are "
- f"not defined in the schema: {additional_relation_property_names}\n"
- f"These properties will be ignored for parameter invalidation."
- )
- parameter_names = parameter_names - additional_relation_property_names
-
- if not parameter_names:
- raise ValueError(
- f"No parameter can be changed to cause status_code {status_code}."
- )
-
- parameter_names = parameter_names - parameters_to_ignore
- parameter_to_invalidate = choice(tuple(parameter_names))
-
- # check for invalid parameters in the provided request_data
- try:
- [parameter_data] = [
- data
- for data in request_data.parameters
- if data["name"] == parameter_to_invalidate
- ]
- except Exception:
- raise ValueError(
- f"{parameter_to_invalidate} not found in provided parameters."
- ) from None
-
- # get the invalid_value for the chosen parameter
- try:
- [invalid_value_for_error_code] = [
- r.invalid_value
- for r in relations_for_status_code
- if r.property_name == parameter_to_invalidate
- and r.invalid_value_error_code == status_code
- ]
- except ValueError:
- invalid_value_for_error_code = NOT_SET
-
- # get the constraint values if available for the chosen parameter
- try:
- [values_from_constraint] = [
- r.values
- for r in relations_for_status_code
- if r.property_name == parameter_to_invalidate
- ]
- except ValueError:
- values_from_constraint = []
-
- # if the parameter was not provided, add it to params / headers
- params, headers = self.ensure_parameter_in_parameters(
- parameter_to_invalidate=parameter_to_invalidate,
- params=params,
- headers=headers,
- parameter_data=parameter_data,
- values_from_constraint=values_from_constraint,
+ return pi.get_invalidated_url(
+ valid_url=valid_url,
+ path=path,
+ base_url=self.base_url,
+ get_dto_class=self.get_dto_class,
+ expected_status_code=expected_status_code,
)
- # determine the invalid_value
- if invalid_value_for_error_code != NOT_SET:
- invalid_value = invalid_value_for_error_code
- else:
- if parameter_to_invalidate in params.keys():
- valid_value = params[parameter_to_invalidate]
- else:
- valid_value = headers[parameter_to_invalidate]
-
- value_schema = resolve_schema(parameter_data["schema"])
- invalid_value = value_utils.get_invalid_value(
- value_schema=value_schema,
- current_value=valid_value,
- values_from_constraint=values_from_constraint,
- )
- logger.debug(f"{parameter_to_invalidate} changed to {invalid_value}")
-
- # update the params / headers and return
- if parameter_to_invalidate in params.keys():
- params[parameter_to_invalidate] = invalid_value
- else:
- headers[parameter_to_invalidate] = invalid_value
- return params, headers
-
- @staticmethod
- 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]]:
- """
- Returns the params, headers tuple with parameter_to_invalidate with a valid
- value to params or headers if not originally present.
- """
- if (
- parameter_to_invalidate not in params.keys()
- and parameter_to_invalidate not in headers.keys()
- ):
- if values_from_constraint:
- valid_value = choice(values_from_constraint)
- else:
- parameter_schema = resolve_schema(parameter_data["schema"])
- valid_value = value_utils.get_valid_value(parameter_schema)
- if (
- parameter_data["in"] == "query"
- and parameter_to_invalidate not in params.keys()
- ):
- params[parameter_to_invalidate] = valid_value
- if (
- parameter_data["in"] == "header"
- and parameter_to_invalidate not in headers.keys()
- ):
- headers[parameter_to_invalidate] = valid_value
- return params, headers
-
+ # endregion
+ # region: resource relations keywords
@keyword
def ensure_in_use(self, url: str, resource_relation: IdReference) -> None:
"""
Ensure that the (right-most) `id` of the resource referenced by the `url`
is used by the resource defined by the `resource_relation`.
"""
- resource_id = ""
-
- endpoint = url.replace(self.base_url, "")
- endpoint_parts = endpoint.split("/")
- parameterized_endpoint = self.get_parametrized_endpoint(endpoint=endpoint)
- parameterized_endpoint_parts = parameterized_endpoint.split("/")
- for part, param_part in zip(
- reversed(endpoint_parts), reversed(parameterized_endpoint_parts)
- ):
- if param_part.endswith("}"):
- resource_id = part
- break
- if not resource_id:
- raise ValueError(f"The provided url ({url}) does not contain an id.")
- request_data = self.get_request_data(
- method="post", endpoint=resource_relation.post_path
- )
- json_data = request_data.dto.as_dict()
- json_data[resource_relation.property_name] = resource_id
- post_url: str = run_keyword(
- "get_valid_url",
- resource_relation.post_path,
- "post",
- )
- response: Response = run_keyword(
- "authorized_request",
- post_url,
- "post",
- request_data.params,
- request_data.headers,
- json_data,
- )
- if not response.ok:
- logger.debug(
- f"POST on {post_url} with json {json_data} failed: {response.json()}"
- )
- response.raise_for_status()
-
- @keyword
- def get_json_data_with_conflict(
- self, url: str, method: str, dto: Dto, conflict_status_code: int
- ) -> dict[str, Any]:
- """
- Return `json_data` based on the `UniquePropertyValueConstraint` that must be
- returned by the `get_relations` implementation on the `dto` for the given
- `conflict_status_code`.
- """
- method = method.lower()
- json_data = dto.as_dict()
- unique_property_value_constraints = [
- r
- for r in dto.get_relations()
- if isinstance(r, UniquePropertyValueConstraint)
- ]
- for relation in unique_property_value_constraints:
- json_data[relation.property_name] = relation.value
- # create a new resource that the original request will conflict with
- if method in ["patch", "put"]:
- post_url_parts = url.split("/")[:-1]
- post_url = "/".join(post_url_parts)
- # the PATCH or PUT may use a different dto than required for POST
- # so a valid POST dto must be constructed
- endpoint = post_url.replace(self.base_url, "")
- request_data = self.get_request_data(endpoint=endpoint, method="post")
- post_json = request_data.dto.as_dict()
- for key in post_json.keys():
- if key in json_data:
- post_json[key] = json_data.get(key)
- else:
- post_url = url
- post_json = json_data
- endpoint = post_url.replace(self.base_url, "")
- request_data = self.get_request_data(endpoint=endpoint, method="post")
- response: Response = run_keyword(
- "authorized_request",
- post_url,
- "post",
- request_data.params,
- request_data.headers,
- post_json,
- )
- # conflicting resource may already exist
- assert (
- response.ok or response.status_code == conflict_status_code
- ), f"get_json_data_with_conflict received {response.status_code}: {response.json()}"
- return json_data
- raise ValueError(
- f"No UniquePropertyValueConstraint in the get_relations list on dto {dto}."
+ rr.ensure_in_use(
+ url=url,
+ base_url=self.base_url,
+ openapi_spec=self.openapi_spec,
+ resource_relation=resource_relation,
)
+ # endregion
+ # region: request keywords
@keyword
def authorized_request( # pylint: disable=too-many-arguments
self,
url: str,
method: str,
- params: dict[str, Any] = {},
- headers: dict[str, str] = {},
- json_data: JSON = {},
+ params: dict[str, Any] | None = None,
+ headers: dict[str, str] | None = None,
+ json_data: JSON = None,
data: Any = None,
files: Any = None,
) -> Response:
@@ -1734,7 +632,7 @@ def authorized_request( # pylint: disable=too-many-arguments
> Note: provided username / password or auth objects take precedence over token
based security
"""
- headers = headers if headers else {}
+ headers = deepcopy(headers) if headers else {}
if self.extra_headers:
headers.update(self.extra_headers)
# if both an auth object and a token are available, auth takes precedence
@@ -1759,90 +657,67 @@ def authorized_request( # pylint: disable=too-many-arguments
logger.debug(f"Response text: {response.text}")
return response
+ # endregion
+ # region: validation keywords
@keyword
def perform_validated_request(
self,
path: str,
status_code: int,
request_values: RequestValues,
- original_data: dict[str, Any] = {},
+ original_data: Mapping[str, object] = default_any_mapping,
) -> None:
"""
This keyword first calls the Authorized Request keyword, then the Validate
Response keyword and finally validates, for `DELETE` operations, whether
the target resource was indeed deleted (OK response) or not (error responses).
"""
- response = run_keyword(
- "authorized_request",
- request_values.url,
- request_values.method,
- request_values.params,
- request_values.headers,
- request_values.json_data,
+ val.perform_validated_request(
+ path=path,
+ status_code=status_code,
+ request_values=request_values,
+ original_data=original_data,
)
- if response.status_code != status_code:
- try:
- response_json = response.json()
- except Exception as _: # pylint: disable=broad-except
- logger.info(
- f"Failed to get json content from response. "
- f"Response text was: {response.text}"
- )
- response_json = {}
- if not response.ok:
- if description := response_json.get("detail"):
- pass
- else:
- description = response_json.get(
- "message", "response contains no message or detail."
- )
- logger.error(f"{response.reason}: {description}")
-
- logger.debug(
- f"\nSend: {_json.dumps(request_values.json_data, indent=4, sort_keys=True)}"
- f"\nGot: {_json.dumps(response_json, indent=4, sort_keys=True)}"
- )
- raise AssertionError(
- f"Response status_code {response.status_code} was not {status_code}"
- )
- run_keyword("validate_response", path, response, original_data)
+ @keyword
+ def validate_response_using_validator(
+ self, request: RequestsOpenAPIRequest, response: RequestsOpenAPIResponse
+ ) -> None:
+ """
+ Validate the `response` for a given `request` against the OpenAPI Spec that is
+ loaded during library initialization.
+ """
+ val.validate_response_using_validator(
+ request=request,
+ response=response,
+ response_validator=self.response_validator,
+ )
- if request_values.method == "DELETE":
- get_request_data = self.get_request_data(endpoint=path, method="GET")
- get_params = get_request_data.params
- get_headers = get_request_data.headers
- get_response = run_keyword(
- "authorized_request", request_values.url, "GET", get_params, get_headers
- )
- if response.ok:
- if get_response.ok:
- raise AssertionError(
- f"Resource still exists after deletion. Url was {request_values.url}"
- )
- # if the path supports GET, 404 is expected, if not 405 is expected
- if get_response.status_code not in [404, 405]:
- logger.warning(
- f"Unexpected response after deleting resource: Status_code "
- f"{get_response.status_code} was received after trying to get {request_values.url} "
- f"after sucessfully deleting it."
- )
- elif not get_response.ok:
- raise AssertionError(
- f"Resource could not be retrieved after failed deletion. "
- f"Url was {request_values.url}, status_code was {get_response.status_code}"
- )
+ @keyword
+ def assert_href_to_resource_is_valid(
+ self, href: str, referenced_resource: dict[str, JSON]
+ ) -> None:
+ """
+ Attempt to GET the resource referenced by the `href` and validate it's equal
+ to the provided `referenced_resource` object / dictionary.
+ """
+ val.assert_href_to_resource_is_valid(
+ href=href,
+ origin=self.origin,
+ base_url=self.base_url,
+ referenced_resource=referenced_resource,
+ )
@keyword
def validate_response(
self,
path: str,
response: Response,
- original_data: dict[str, Any] = {},
+ original_data: Mapping[str, object] = default_any_mapping,
) -> None:
"""
Validate the `response` by performing the following validations:
- - validate the `response` against the openapi schema for the `endpoint`
+ - validate the `response` against the openapi schema for the `path`
- validate that the response does not contain extra properties
- validate that a href, if present, refers to the correct resource
- validate that the value for a property that is in the response is equal to
@@ -1850,278 +725,36 @@ def validate_response(
- validate that no `original_data` is preserved when performing a PUT operation
- validate that a PATCH operation only updates the provided properties
"""
- if response.status_code == 204:
- assert not response.content
- return None
-
- try:
- self._validate_response_against_spec(response)
- except OpenAPIError as exception:
- raise Failure(f"Response did not pass schema validation: {exception}")
-
- request_method = response.request.method
- if request_method is None:
- logger.warning(
- f"Could not validate response for path {path}; no method found "
- f"on the request property of the provided response."
- )
- return None
-
- response_spec = self._get_response_spec(
+ val.validate_response(
path=path,
- method=request_method,
- status_code=response.status_code,
- )
-
- content_type_from_response = response.headers.get("Content-Type", "unknown")
- mime_type_from_response, _, _ = content_type_from_response.partition(";")
-
- if not response_spec.get("content"):
- logger.warning(
- "The response cannot be validated: 'content' not specified in the OAS."
- )
- return None
-
- # multiple content types can be specified in the OAS
- content_types = list(response_spec["content"].keys())
- supported_types = [
- ct for ct in content_types if ct.partition(";")[0].endswith("json")
- ]
- if not supported_types:
- raise NotImplementedError(
- f"The content_types '{content_types}' are not supported. "
- f"Only json types are currently supported."
- )
- content_type = supported_types[0]
- mime_type = content_type.partition(";")[0]
-
- if mime_type != mime_type_from_response:
- raise ValueError(
- f"Content-Type '{content_type_from_response}' of the response "
- f"does not match '{mime_type}' as specified in the OpenAPI document."
- )
-
- json_response = response.json()
- response_schema = resolve_schema(
- response_spec["content"][content_type]["schema"]
+ response=response,
+ response_validator=self.response_validator,
+ server_validation_warning_logged=self._server_validation_warning_logged,
+ disable_server_validation=self.disable_server_validation,
+ invalid_property_default_response=self.invalid_property_default_response,
+ response_validation=self.response_validation,
+ openapi_spec=self.openapi_spec,
+ original_data=original_data,
)
- response_types = response_schema.get("types")
- if response_types:
- # In case of oneOf / anyOf there can be multiple possible response types
- # which makes generic validation too complex
- return None
- response_type = response_schema.get("type", "undefined")
- if response_type not in ["object", "array"]:
- self._validate_value_type(value=json_response, expected_type=response_type)
- return None
-
- if list_item_schema := response_schema.get("items"):
- if not isinstance(json_response, list):
- raise AssertionError(
- f"Response schema violation: the schema specifies an array as "
- f"response type but the response was of type {type(json_response)}."
- )
- type_of_list_items = list_item_schema.get("type")
- if type_of_list_items == "object":
- for resource in json_response:
- run_keyword(
- "validate_resource_properties", resource, list_item_schema
- )
- else:
- for item in json_response:
- self._validate_value_type(
- value=item, expected_type=type_of_list_items
- )
- # no further validation; value validation of individual resources should
- # be performed on the endpoints for the specific resource
- return None
-
- run_keyword("validate_resource_properties", json_response, response_schema)
- # ensure the href is valid if present in the response
- if href := json_response.get("href"):
- self._assert_href_is_valid(href, json_response)
- # every property that was sucessfully send and that is in the response
- # schema must have the value that was send
- if response.ok and response.request.method in ["POST", "PUT", "PATCH"]:
- run_keyword("validate_send_response", response, original_data)
- return None
-
- def _assert_href_is_valid(self, href: str, json_response: dict[str, Any]) -> None:
- url = f"{self.origin}{href}"
- path = url.replace(self.base_url, "")
- request_data = self.get_request_data(endpoint=path, method="GET")
- params = request_data.params
- headers = request_data.headers
- get_response = run_keyword("authorized_request", url, "GET", params, headers)
- assert (
- get_response.json() == json_response
- ), f"{get_response.json()} not equal to original {json_response}"
-
- def _validate_response_against_spec(self, response: Response) -> None:
- try:
- self.validate_response_vs_spec(
- request=RequestsOpenAPIRequest(response.request),
- response=RequestsOpenAPIResponse(response),
- )
- except (ResponseValidationError, ServerNotFound) as exception:
- errors: list[InvalidSchemaValue] = exception.__cause__
- validation_errors: list[ValidationError] = getattr(
- errors, "schema_errors", []
- )
- if validation_errors:
- error_message = "\n".join(
- [
- f"{list(error.schema_path)}: {error.message}"
- for error in validation_errors
- ]
- )
- else:
- error_message = str(exception)
-
- if isinstance(exception, ServerNotFound):
- if not self._server_validation_warning_logged:
- logger.warning(
- f"ServerNotFound was raised during response validation. "
- f"Due to this, no full response validation will be performed."
- f"\nThe original error was: {error_message}"
- )
- self._server_validation_warning_logged = True
- if self.disable_server_validation:
- return
- if response.status_code == self.invalid_property_default_response:
- logger.debug(error_message)
- return
- if self.response_validation == ValidationLevel.STRICT:
- logger.error(error_message)
- raise exception
- if self.response_validation == ValidationLevel.WARN:
- logger.warning(error_message)
- elif self.response_validation == ValidationLevel.INFO:
- logger.info(error_message)
-
@keyword
def validate_resource_properties(
- self, resource: dict[str, Any], schema: dict[str, Any]
+ self, resource: dict[str, JSON], schema: dict[str, JSON]
) -> None:
"""
Validate that the `resource` does not contain any properties that are not
defined in the `schema_properties`.
"""
- schema_properties = schema.get("properties", {})
- property_names_from_schema = set(schema_properties.keys())
- property_names_in_resource = set(resource.keys())
-
- if property_names_from_schema != property_names_in_resource:
- # The additionalProperties property determines whether properties with
- # unspecified names are allowed. This property can be boolean or an object
- # (dict) that specifies the type of any additional properties.
- additional_properties = schema.get("additionalProperties", True)
- if isinstance(additional_properties, bool):
- allow_additional_properties = additional_properties
- allowed_additional_properties_type = None
- else:
- allow_additional_properties = True
- allowed_additional_properties_type = additional_properties["type"]
-
- extra_property_names = property_names_in_resource.difference(
- property_names_from_schema
- )
- if allow_additional_properties:
- # If a type is defined for extra properties, validate them
- if allowed_additional_properties_type:
- extra_properties = {
- key: value
- for key, value in resource.items()
- if key in extra_property_names
- }
- self._validate_type_of_extra_properties(
- extra_properties=extra_properties,
- expected_type=allowed_additional_properties_type,
- )
- # If allowed, validation should not fail on extra properties
- extra_property_names = set()
-
- required_properties = set(schema.get("required", []))
- missing_properties = required_properties.difference(
- property_names_in_resource
- )
-
- if extra_property_names or missing_properties:
- extra = (
- f"\n\tExtra properties in response: {extra_property_names}"
- if extra_property_names
- else ""
- )
- missing = (
- f"\n\tRequired properties missing in response: {missing_properties}"
- if missing_properties
- else ""
- )
- raise AssertionError(
- f"Response schema violation: the response contains properties that are "
- f"not specified in the schema or does not contain properties that are "
- f"required according to the schema."
- f"\n\tReceived in the response: {property_names_in_resource}"
- f"\n\tDefined in the schema: {property_names_from_schema}"
- f"{extra}{missing}"
- )
-
- @staticmethod
- def _validate_value_type(value: Any, expected_type: str) -> None:
- type_mapping = {
- "string": str,
- "number": float,
- "integer": int,
- "boolean": bool,
- "array": list,
- "object": dict,
- }
- python_type = type_mapping.get(expected_type, None)
- if python_type is None:
- raise AssertionError(
- f"Validation of type '{expected_type}' is not supported."
- )
- if not isinstance(value, python_type):
- raise AssertionError(f"{value} is not of type {expected_type}")
-
- @staticmethod
- def _validate_type_of_extra_properties(
- extra_properties: dict[str, Any], expected_type: str
- ) -> None:
- type_mapping = {
- "string": str,
- "number": float,
- "integer": int,
- "boolean": bool,
- "array": list,
- "object": dict,
- }
-
- python_type = type_mapping.get(expected_type, None)
- if python_type is None:
- logger.warning(
- f"Additonal properties were not validated: "
- f"type '{expected_type}' is not supported."
- )
- return
-
- invalid_extra_properties = {
- key: value
- for key, value in extra_properties.items()
- if not isinstance(value, python_type)
- }
- if invalid_extra_properties:
- raise AssertionError(
- f"Response contains invalid additionalProperties: "
- f"{invalid_extra_properties} are not of type {expected_type}."
- )
+ val.validate_resource_properties(
+ resource=resource,
+ schema=schema,
+ )
@staticmethod
@keyword
def validate_send_response(
response: Response,
- original_data: dict[str, Any] = {},
+ original_data: Mapping[str, object] = default_any_mapping,
) -> None:
"""
Validate that each property that was send that is in the response has the value
@@ -2129,102 +762,130 @@ def validate_send_response(
In case a PATCH request, validate that only the properties that were patched
have changed and that other properties are still at their pre-patch values.
"""
+ val.validate_send_response(response=response, original_data=original_data)
+
+ # endregion
+
+ @property
+ def origin(self) -> str:
+ return self._origin
+
+ @property
+ def base_url(self) -> str:
+ return f"{self.origin}{self._base_path}"
+
+ @cached_property
+ def validation_spec(self) -> Spec:
+ _, validation_spec, _ = self._load_specs_and_validator()
+ return validation_spec
+
+ @property
+ def openapi_spec(self) -> dict[str, JSON]:
+ """Return a deepcopy of the parsed openapi document."""
+ # protect the parsed openapi spec from being mutated by reference
+ return deepcopy(self._openapi_spec)
+
+ @cached_property
+ def _openapi_spec(self) -> dict[str, JSON]:
+ parser, _, _ = self._load_specs_and_validator()
+ return parser.specification # type: ignore[no-any-return]
+
+ @cached_property
+ def response_validator(
+ self,
+ ) -> ResponseValidatorType:
+ _, _, response_validator = self._load_specs_and_validator()
+ return response_validator
+
+ def _get_json_types_from_spec(self, spec: dict[str, JSON]) -> set[str]:
+ json_types: set[str] = set(self._get_json_types(spec))
+ return {json_type for json_type in json_types if json_type is not None}
+
+ def _get_json_types(self, item: object) -> Generator[str, None, None]:
+ if isinstance(item, dict):
+ content_dict = item.get("content")
+ if content_dict is None:
+ for value in item.values():
+ yield from self._get_json_types(value)
- def validate_list_response(
- send_list: list[Any], received_list: list[Any]
- ) -> None:
- for item in send_list:
- if item not in received_list:
- raise AssertionError(
- f"Received value '{received_list}' does "
- f"not contain '{item}' in the {response.request.method} request."
- f"\nSend: {_json.dumps(send_json, indent=4, sort_keys=True)}"
- f"\nGot: {_json.dumps(response_data, indent=4, sort_keys=True)}"
- )
-
- def validate_dict_response(
- send_dict: dict[str, Any], received_dict: dict[str, Any]
- ) -> None:
- for send_property_name, send_property_value in send_dict.items():
- # sometimes, a property in the request is not in the response, e.g. a password
- if send_property_name not in received_dict.keys():
- continue
- if send_property_value is not None:
- # if a None value is send, the target property should be cleared or
- # reverted to the default value (which cannot be specified in the
- # openapi document)
- received_value = received_dict[send_property_name]
- # In case of lists / arrays, the send values are often appended to
- # existing data
- if isinstance(received_value, list):
- validate_list_response(
- send_list=send_property_value, received_list=received_value
- )
- continue
-
- # when dealing with objects, we'll need to iterate the properties
- if isinstance(received_value, dict):
- validate_dict_response(
- send_dict=send_property_value, received_dict=received_value
- )
- continue
-
- assert received_value == send_property_value, (
- f"Received value for {send_property_name} '{received_value}' does not "
- f"match '{send_property_value}' in the {response.request.method} request."
- f"\nSend: {_json.dumps(send_json, indent=4, sort_keys=True)}"
- f"\nGot: {_json.dumps(response_data, indent=4, sort_keys=True)}"
- )
-
- if response.request.body is None:
- logger.warning(
- "Could not validate send response; the body of the request property "
- "on the provided response was None."
+ else:
+ for content_type in content_dict:
+ if "json" in content_type:
+ content_type_without_charset, _, _ = content_type.partition(";")
+ yield content_type_without_charset
+
+ if isinstance(item, list):
+ for list_item in item:
+ yield from self._get_json_types(list_item)
+
+ def _load_specs_and_validator(
+ self,
+ ) -> tuple[
+ ResolvingParser,
+ Spec,
+ ResponseValidatorType,
+ ]:
+ def recursion_limit_handler(
+ limit: int,
+ refstring: str,
+ recursions: JSON, # pylint: disable=unused-argument
+ ) -> JSON:
+ return self._recursion_default
+
+ try:
+ # Since parsing of the OAS and creating the Spec can take a long time,
+ # they are cached. This is done by storing them in an imported module that
+ # will have a global scope due to how the Python import system works. This
+ # ensures that in a Suite of Suites where multiple Suites use the same
+ # `source`, that OAS is only parsed / loaded once.
+ cached_parser = PARSER_CACHE.get(self._source, None)
+ if cached_parser:
+ return (
+ cached_parser.parser,
+ cached_parser.validation_spec,
+ cached_parser.response_validator,
+ )
+
+ parser = ResolvingParser(
+ self._source,
+ backend="openapi-spec-validator",
+ recursion_limit=self._recursion_limit,
+ recursion_limit_handler=recursion_limit_handler,
)
- return None
- if isinstance(response.request.body, bytes):
- send_json = _json.loads(response.request.body.decode("UTF-8"))
- else:
- send_json = _json.loads(response.request.body)
-
- response_data = response.json()
- # POST on /resource_type/{id}/array_item/ will return the updated {id} resource
- # instead of a newly created resource. In this case, the send_json must be
- # in the array of the 'array_item' property on {id}
- send_path: str = response.request.path_url
- response_path = response_data.get("href", None)
- if response_path and send_path not in response_path:
- property_to_check = send_path.replace(response_path, "")[1:]
- if response_data.get(property_to_check) and isinstance(
- response_data[property_to_check], list
- ):
- item_list: list[dict[str, Any]] = response_data[property_to_check]
- # Use the (mandatory) id to get the POSTed resource from the list
- [response_data] = [
- item for item in item_list if item["id"] == send_json["id"]
- ]
-
- # incoming arguments are dictionaries, so they can be validated as such
- validate_dict_response(send_dict=send_json, received_dict=response_data)
-
- # In case of PATCH requests, ensure that only send properties have changed
- if original_data:
- for send_property_name, send_value in original_data.items():
- if send_property_name not in send_json.keys():
- assert send_value == response_data[send_property_name], (
- f"Received value for {send_property_name} '{response_data[send_property_name]}' does not "
- f"match '{send_value}' in the pre-patch data"
- f"\nPre-patch: {_json.dumps(original_data, indent=4, sort_keys=True)}"
- f"\nGot: {_json.dumps(response_data, indent=4, sort_keys=True)}"
- )
- return None
-
- def _get_response_spec(
- self, path: str, method: str, status_code: int
- ) -> dict[str, Any]:
- method = method.lower()
- status = str(status_code)
- spec: dict[str, Any] = {**self.openapi_spec}["paths"][path][method][
- "responses"
- ][status]
- return spec
+
+ if parser.specification is None: # pragma: no cover
+ raise FatalError(
+ "Source was loaded, but no specification was present after parsing."
+ )
+
+ validation_spec = Spec.from_dict(parser.specification) # pyright: ignore[reportArgumentType]
+
+ json_types_from_spec: set[str] = self._get_json_types_from_spec(
+ parser.specification
+ )
+ extra_deserializers = {
+ json_type: _json.loads for json_type in json_types_from_spec
+ }
+ config = Config(extra_media_type_deserializers=extra_deserializers) # type: ignore[arg-type]
+ openapi = OpenAPI(spec=validation_spec, config=config)
+ response_validator: ResponseValidatorType = openapi.validate_response # type: ignore[assignment]
+
+ PARSER_CACHE[self._source] = CachedParser(
+ parser=parser,
+ validation_spec=validation_spec,
+ response_validator=response_validator,
+ )
+
+ return parser, validation_spec, response_validator
+
+ except ResolutionError as exception:
+ raise FatalError(
+ f"ResolutionError while trying to load openapi spec: {exception}"
+ ) from exception
+ except ValidationError as exception:
+ raise FatalError(
+ f"ValidationError while trying to load openapi spec: {exception}"
+ ) from exception
+
+ def read_paths(self) -> dict[str, JSON]:
+ return self.openapi_spec["paths"] # type: ignore[return-value]
diff --git a/src/OpenApiLibCore/path_functions.py b/src/OpenApiLibCore/path_functions.py
new file mode 100644
index 0000000..f41b838
--- /dev/null
+++ b/src/OpenApiLibCore/path_functions.py
@@ -0,0 +1,209 @@
+"""Module holding the functions related to paths and urls."""
+
+import json as _json
+from itertools import zip_longest
+from random import choice
+from typing import Any
+
+from requests import Response
+from robot.libraries.BuiltIn import BuiltIn
+
+from OpenApiLibCore.dto_base import PathPropertiesConstraint
+from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
+from OpenApiLibCore.request_data import RequestData
+
+run_keyword = BuiltIn().run_keyword
+
+
+def match_parts(parts: list[str], spec_parts: list[str]) -> bool:
+ for part, spec_part in zip_longest(parts, spec_parts, fillvalue="Filler"):
+ if part == "Filler" or spec_part == "Filler":
+ return False
+ if part != spec_part and not spec_part.startswith("{"):
+ return False
+ return True
+
+
+def get_parametrized_path(path: str, openapi_spec: dict[str, Any]) -> str:
+ path_parts = path.split("/")
+ # if the last part is empty, the path has a trailing `/` that
+ # should be ignored during matching
+ if path_parts[-1] == "":
+ _ = path_parts.pop(-1)
+
+ spec_paths: list[str] = {**openapi_spec}["paths"].keys()
+
+ candidates: list[str] = []
+
+ for spec_path in spec_paths:
+ spec_path_parts = spec_path.split("/")
+ # ignore trailing `/` the same way as for path_parts
+ if spec_path_parts[-1] == "":
+ _ = spec_path_parts.pop(-1)
+ if match_parts(path_parts, spec_path_parts):
+ candidates.append(spec_path)
+
+ if not candidates:
+ raise ValueError(f"{path} not found in paths section of the OpenAPI document.")
+
+ if len(candidates) == 1:
+ return candidates[0]
+ # Multiple matches can happen in APIs with overloaded paths, e.g.
+ # /users/me
+ # /users/${user_id}
+ # In this case, find the closest (or exact) match
+ exact_match = [c for c in candidates if c == path]
+ if exact_match:
+ return exact_match[0]
+ # TODO: Implement a decision mechanism when real-world examples become available
+ # In the face of ambiguity, refuse the temptation to guess.
+ raise ValueError(f"{path} matched to multiple paths: {candidates}")
+
+
+def get_valid_url(
+ path: str,
+ base_url: str,
+ get_dto_class: GetDtoClassType,
+ openapi_spec: dict[str, Any],
+) -> str:
+ try:
+ # path can be partially resolved or provided by a PathPropertiesConstraint
+ parametrized_path = get_parametrized_path(path=path, openapi_spec=openapi_spec)
+ _ = openapi_spec["paths"][parametrized_path]
+ except KeyError:
+ raise ValueError(
+ f"{path} not found in paths section of the OpenAPI document."
+ ) from None
+ dto_class = get_dto_class(path=path, method="get")
+ relations = dto_class.get_relations()
+ paths = [p.path for p in relations if isinstance(p, PathPropertiesConstraint)]
+ if paths:
+ url = f"{base_url}{choice(paths)}"
+ return url
+ path_parts = list(path.split("/"))
+ for index, part in enumerate(path_parts):
+ if part.startswith("{") and part.endswith("}"):
+ type_path_parts = path_parts[slice(index)]
+ type_path = "/".join(type_path_parts)
+ existing_id: str | int | float = run_keyword(
+ "get_valid_id_for_path", type_path
+ )
+ path_parts[index] = str(existing_id)
+ resolved_path = "/".join(path_parts)
+ url = f"{base_url}{resolved_path}"
+ return url
+
+
+def get_valid_id_for_path(
+ path: str,
+ get_id_property_name: GetIdPropertyNameType,
+) -> str | int:
+ url: str = run_keyword("get_valid_url", path)
+ # Try to create a new resource to prevent conflicts caused by
+ # operations performed on the same resource by other test cases
+ request_data: RequestData = run_keyword("get_request_data", path, "post")
+
+ response: Response = run_keyword(
+ "authorized_request",
+ url,
+ "post",
+ request_data.get_required_params(),
+ request_data.get_required_headers(),
+ request_data.get_required_properties_dict(),
+ )
+
+ id_property, id_transformer = get_id_property_name(path=path)
+
+ if not response.ok:
+ # If a new resource cannot be created using POST, try to retrieve a
+ # valid id using a GET request.
+ try:
+ valid_id = choice(run_keyword("get_ids_from_url", url))
+ return id_transformer(valid_id)
+ except Exception as exception:
+ raise AssertionError(
+ f"Failed to get a valid id using GET on {url}"
+ ) from exception
+
+ response_data = response.json()
+ if prepared_body := response.request.body:
+ if isinstance(prepared_body, bytes):
+ send_json = _json.loads(prepared_body.decode("UTF-8"))
+ else:
+ send_json = _json.loads(prepared_body)
+ else:
+ send_json = None
+
+ # no support for retrieving an id from an array returned on a POST request
+ if isinstance(response_data, list):
+ raise NotImplementedError(
+ f"Unexpected response body for POST request: expected an object but "
+ f"received an array ({response_data})"
+ )
+
+ # POST on /resource_type/{id}/array_item/ will return the updated {id} resource
+ # instead of a newly created resource. In this case, the send_json must be
+ # in the array of the 'array_item' property on {id}
+ send_path: str = response.request.path_url
+ response_href: str = response_data.get("href", "")
+ if response_href and (send_path not in response_href) and send_json:
+ try:
+ property_to_check = send_path.replace(response_href, "")[1:]
+ item_list: list[dict[str, Any]] = response_data[property_to_check]
+ # Use the (mandatory) id to get the POSTed resource from the list
+ [valid_id] = [
+ item[id_property]
+ for item in item_list
+ if item[id_property] == send_json[id_property]
+ ]
+ except Exception as exception:
+ raise AssertionError(
+ f"Failed to get a valid id from {response_href}"
+ ) from exception
+ else:
+ try:
+ valid_id = response_data[id_property]
+ except KeyError:
+ raise AssertionError(
+ f"Failed to get a valid id from {response_data}"
+ ) from None
+ return id_transformer(valid_id)
+
+
+def get_ids_from_url(
+ url: str,
+ get_id_property_name: GetIdPropertyNameType,
+) -> list[str]:
+ path: str = run_keyword("get_parameterized_path_from_url", url)
+ request_data: RequestData = run_keyword("get_request_data", path, "get")
+ response = run_keyword(
+ "authorized_request",
+ url,
+ "get",
+ request_data.get_required_params(),
+ request_data.get_required_headers(),
+ )
+ response.raise_for_status()
+ response_data: dict[str, Any] | list[dict[str, Any]] = response.json()
+
+ # determine the property name to use
+ mapping = get_id_property_name(path=path)
+ if isinstance(mapping, str):
+ id_property = mapping
+ else:
+ id_property, _ = mapping
+
+ if isinstance(response_data, list):
+ valid_ids: list[str] = [item[id_property] for item in response_data]
+ return valid_ids
+ # if the response is an object (dict), check if it's hal+json
+ if embedded := response_data.get("_embedded"):
+ # there should be 1 item in the dict that has a value that's a list
+ for value in embedded.values():
+ if isinstance(value, list):
+ valid_ids = [item[id_property] for item in value]
+ return valid_ids
+ if (valid_id := response_data.get(id_property)) is not None:
+ return [valid_id]
+ valid_ids = [item[id_property] for item in response_data["items"]]
+ return valid_ids
diff --git a/src/OpenApiLibCore/path_invalidation.py b/src/OpenApiLibCore/path_invalidation.py
new file mode 100644
index 0000000..29b2283
--- /dev/null
+++ b/src/OpenApiLibCore/path_invalidation.py
@@ -0,0 +1,44 @@
+"""Module holding functions related to invalidation of paths and urls."""
+
+from random import choice
+from uuid import uuid4
+
+from robot.libraries.BuiltIn import BuiltIn
+
+from OpenApiLibCore.dto_base import PathPropertiesConstraint
+from OpenApiLibCore.protocols import GetDtoClassType
+
+run_keyword = BuiltIn().run_keyword
+
+
+def get_invalidated_url(
+ valid_url: str,
+ path: str,
+ base_url: str,
+ get_dto_class: GetDtoClassType,
+ expected_status_code: int,
+) -> str:
+ dto_class = get_dto_class(path=path, method="get")
+ relations = dto_class.get_relations()
+ paths = [
+ p.invalid_value
+ for p in relations
+ if isinstance(p, PathPropertiesConstraint)
+ and p.invalid_value_error_code == expected_status_code
+ ]
+ if paths:
+ url = f"{base_url}{choice(paths)}"
+ return url
+ parameterized_path: str = run_keyword("get_parameterized_path_from_url", valid_url)
+ parameterized_url = base_url + parameterized_path
+ valid_url_parts = list(reversed(valid_url.split("/")))
+ parameterized_parts = reversed(parameterized_url.split("/"))
+ for index, (parameterized_part, _) in enumerate(
+ zip(parameterized_parts, valid_url_parts)
+ ):
+ if parameterized_part.startswith("{") and parameterized_part.endswith("}"):
+ valid_url_parts[index] = uuid4().hex
+ valid_url_parts.reverse()
+ invalid_url = "/".join(valid_url_parts)
+ return invalid_url
+ raise ValueError(f"{parameterized_path} could not be invalidated.")
diff --git a/src/OpenApiLibCore/protocols.py b/src/OpenApiLibCore/protocols.py
new file mode 100644
index 0000000..5ddeb93
--- /dev/null
+++ b/src/OpenApiLibCore/protocols.py
@@ -0,0 +1,30 @@
+"""A module holding Protcols."""
+
+from typing import Callable, Protocol, Type
+
+from openapi_core.contrib.requests import (
+ RequestsOpenAPIRequest,
+ RequestsOpenAPIResponse,
+)
+
+from OpenApiLibCore.dto_base import Dto
+
+
+class ResponseValidatorType(Protocol):
+ def __call__(
+ self, request: RequestsOpenAPIRequest, response: RequestsOpenAPIResponse
+ ) -> None: ...
+
+
+class GetDtoClassType(Protocol):
+ def __init__(self, mappings_module_name: str) -> None: ...
+
+ def __call__(self, path: str, method: str) -> Type[Dto]: ...
+
+
+class GetIdPropertyNameType(Protocol):
+ def __init__(self, mappings_module_name: str) -> None: ...
+
+ def __call__(
+ self, path: str
+ ) -> tuple[str, Callable[[str], str] | Callable[[int], int]]: ...
diff --git a/src/OpenApiLibCore/request_data.py b/src/OpenApiLibCore/request_data.py
new file mode 100644
index 0000000..5c9e03f
--- /dev/null
+++ b/src/OpenApiLibCore/request_data.py
@@ -0,0 +1,258 @@
+"""Module holding the classes used to manage request data."""
+
+from copy import deepcopy
+from dataclasses import dataclass, field
+from functools import cached_property
+from random import sample
+from typing import Any
+
+from OpenApiLibCore.dto_base import (
+ Dto,
+ resolve_schema,
+)
+from OpenApiLibCore.dto_utils import DefaultDto
+
+
+@dataclass
+class RequestValues:
+ """Helper class to hold parameter values needed to make a request."""
+
+ url: str
+ method: str
+ params: dict[str, Any] = field(default_factory=dict)
+ headers: dict[str, str] = field(default_factory=dict)
+ json_data: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class RequestData:
+ """Helper class to manage parameters used when making requests."""
+
+ dto: Dto | DefaultDto = field(default_factory=DefaultDto)
+ dto_schema: dict[str, Any] = field(default_factory=dict)
+ parameters: list[dict[str, Any]] = field(default_factory=list)
+ params: dict[str, Any] = field(default_factory=dict)
+ headers: dict[str, Any] = field(default_factory=dict)
+ has_body: bool = True
+
+ def __post_init__(self) -> None:
+ # prevent modification by reference
+ self.dto_schema = deepcopy(self.dto_schema)
+ self.parameters = deepcopy(self.parameters)
+ self.params = deepcopy(self.params)
+ self.headers = deepcopy(self.headers)
+
+ @property
+ def has_optional_properties(self) -> bool:
+ """Whether or not the dto data (json data) contains optional properties."""
+
+ def is_required_property(property_name: str) -> bool:
+ return property_name in self.dto_schema.get("required", [])
+
+ properties = (self.dto.as_dict()).keys()
+ return not all(map(is_required_property, properties))
+
+ @property
+ def has_optional_params(self) -> bool:
+ """Whether or not any of the query parameters are optional."""
+
+ def is_optional_param(query_param: str) -> bool:
+ optional_params = [
+ p.get("name")
+ for p in self.parameters
+ if p.get("in") == "query" and not p.get("required")
+ ]
+ return query_param in optional_params
+
+ return any(map(is_optional_param, self.params))
+
+ @cached_property
+ def params_that_can_be_invalidated(self) -> set[str]:
+ """
+ The query parameters that can be invalidated by violating data
+ restrictions, data type or by not providing them in a request.
+ """
+ result = set()
+ params = [h for h in self.parameters if h.get("in") == "query"]
+ for param in params:
+ # required params can be omitted to invalidate a request
+ if param["required"]:
+ result.add(param["name"])
+ continue
+
+ schema = resolve_schema(param["schema"])
+ if schema.get("type", None):
+ param_types = [schema]
+ else:
+ param_types = schema["types"]
+ for param_type in param_types:
+ # any basic non-string type except "null" can be invalidated by
+ # replacing it with a string
+ if param_type["type"] not in ["string", "array", "object", "null"]:
+ result.add(param["name"])
+ continue
+ # enums, strings and arrays with boundaries can be invalidated
+ if set(param_type.keys()).intersection(
+ {
+ "enum",
+ "minLength",
+ "maxLength",
+ "minItems",
+ "maxItems",
+ }
+ ):
+ result.add(param["name"])
+ continue
+ # an array of basic non-string type can be invalidated by replacing the
+ # items in the array with strings
+ if param_type["type"] == "array" and param_type["items"][
+ "type"
+ ] not in [
+ "string",
+ "array",
+ "object",
+ "null",
+ ]:
+ result.add(param["name"])
+ return result
+
+ @property
+ def has_optional_headers(self) -> bool:
+ """Whether or not any of the headers are optional."""
+
+ def is_optional_header(header: str) -> bool:
+ optional_headers = [
+ p.get("name")
+ for p in self.parameters
+ if p.get("in") == "header" and not p.get("required")
+ ]
+ return header in optional_headers
+
+ return any(map(is_optional_header, self.headers))
+
+ @cached_property
+ def headers_that_can_be_invalidated(self) -> set[str]:
+ """
+ The header parameters that can be invalidated by violating data
+ restrictions or by not providing them in a request.
+ """
+ result = set()
+ headers = [h for h in self.parameters if h.get("in") == "header"]
+ for header in headers:
+ # required headers can be omitted to invalidate a request
+ if header["required"]:
+ result.add(header["name"])
+ continue
+
+ schema = resolve_schema(header["schema"])
+ if schema.get("type", None):
+ header_types = [schema]
+ else:
+ header_types = schema["types"]
+ for header_type in header_types:
+ # any basic non-string type except "null" can be invalidated by
+ # replacing it with a string
+ if header_type["type"] not in ["string", "array", "object", "null"]:
+ result.add(header["name"])
+ continue
+ # enums, strings and arrays with boundaries can be invalidated
+ if set(header_type.keys()).intersection(
+ {
+ "enum",
+ "minLength",
+ "maxLength",
+ "minItems",
+ "maxItems",
+ }
+ ):
+ result.add(header["name"])
+ continue
+ # an array of basic non-string type can be invalidated by replacing the
+ # items in the array with strings
+ if header_type["type"] == "array" and header_type["items"][
+ "type"
+ ] not in [
+ "string",
+ "array",
+ "object",
+ "null",
+ ]:
+ result.add(header["name"])
+ return result
+
+ def get_required_properties_dict(self) -> dict[str, Any]:
+ """Get the json-compatible dto data containing only the required properties."""
+ relations = self.dto.get_relations()
+ mandatory_properties = [
+ relation.property_name
+ for relation in relations
+ if getattr(relation, "treat_as_mandatory", False)
+ ]
+ required_properties: list[str] = self.dto_schema.get("required", [])
+ required_properties.extend(mandatory_properties)
+
+ required_properties_dict: dict[str, Any] = {}
+ for key, value in (self.dto.as_dict()).items():
+ if key in required_properties:
+ required_properties_dict[key] = value
+ return required_properties_dict
+
+ def get_minimal_body_dict(self) -> dict[str, Any]:
+ required_properties_dict = self.get_required_properties_dict()
+
+ min_properties = self.dto_schema.get("minProperties", 0)
+ number_of_optional_properties_to_add = min_properties - len(
+ required_properties_dict
+ )
+
+ if number_of_optional_properties_to_add < 1:
+ return required_properties_dict
+
+ optional_properties_dict = {
+ k: v
+ for k, v in self.dto.as_dict().items()
+ if k not in required_properties_dict
+ }
+ optional_properties_to_keep = sample(
+ sorted(optional_properties_dict), number_of_optional_properties_to_add
+ )
+ optional_properties_dict = {
+ k: v
+ for k, v in optional_properties_dict.items()
+ if k in optional_properties_to_keep
+ }
+
+ return {**required_properties_dict, **optional_properties_dict}
+
+ def get_required_params(self) -> dict[str, str]:
+ """Get the params dict containing only the required query parameters."""
+ return {
+ k: v for k, v in self.params.items() if k in self.required_parameter_names
+ }
+
+ def get_required_headers(self) -> dict[str, str]:
+ """Get the headers dict containing only the required headers."""
+ return {
+ k: v for k, v in self.headers.items() if k in self.required_parameter_names
+ }
+
+ @property
+ def required_parameter_names(self) -> list[str]:
+ """
+ The names of the mandatory parameters, including the parameters configured to be
+ treated as mandatory using a PropertyValueConstraint.
+ """
+ relations = self.dto.get_parameter_relations()
+ mandatory_property_names = [
+ relation.property_name
+ for relation in relations
+ if getattr(relation, "treat_as_mandatory", False)
+ ]
+ parameter_names = [p["name"] for p in self.parameters]
+ mandatory_parameters = [
+ p for p in mandatory_property_names if p in parameter_names
+ ]
+
+ required_parameters = [p["name"] for p in self.parameters if p.get("required")]
+ required_parameters.extend(mandatory_parameters)
+ return required_parameters
diff --git a/src/OpenApiLibCore/resource_relations.py b/src/OpenApiLibCore/resource_relations.py
new file mode 100644
index 0000000..6c25393
--- /dev/null
+++ b/src/OpenApiLibCore/resource_relations.py
@@ -0,0 +1,54 @@
+"""Module holding the functions related to relations between resources."""
+
+from typing import Any
+
+from requests import Response
+from robot.api import logger
+from robot.libraries.BuiltIn import BuiltIn
+
+import OpenApiLibCore.path_functions as pf
+from OpenApiLibCore.dto_base import IdReference
+from OpenApiLibCore.request_data import RequestData
+
+run_keyword = BuiltIn().run_keyword
+
+
+def ensure_in_use(
+ url: str,
+ base_url: str,
+ openapi_spec: dict[str, Any],
+ resource_relation: IdReference,
+) -> None:
+ resource_id = ""
+
+ path = url.replace(base_url, "")
+ path_parts = path.split("/")
+ parameterized_path = pf.get_parametrized_path(path=path, openapi_spec=openapi_spec)
+ parameterized_path_parts = parameterized_path.split("/")
+ for part, param_part in zip(
+ reversed(path_parts), reversed(parameterized_path_parts)
+ ):
+ if param_part.endswith("}"):
+ resource_id = part
+ break
+ if not resource_id:
+ raise ValueError(f"The provided url ({url}) does not contain an id.")
+ request_data: RequestData = run_keyword(
+ "get_request_data", resource_relation.post_path, "post"
+ )
+ json_data = request_data.dto.as_dict()
+ json_data[resource_relation.property_name] = resource_id
+ post_url: str = run_keyword("get_valid_url", resource_relation.post_path)
+ response: Response = run_keyword(
+ "authorized_request",
+ post_url,
+ "post",
+ request_data.params,
+ request_data.headers,
+ json_data,
+ )
+ if not response.ok:
+ logger.debug(
+ f"POST on {post_url} with json {json_data} failed: {response.json()}"
+ )
+ response.raise_for_status()
diff --git a/src/OpenApiLibCore/validation.py b/src/OpenApiLibCore/validation.py
new file mode 100644
index 0000000..9150ef8
--- /dev/null
+++ b/src/OpenApiLibCore/validation.py
@@ -0,0 +1,497 @@
+"""Module holding the functions related to validation of requests and responses."""
+
+import json as _json
+from enum import Enum
+from http import HTTPStatus
+from typing import Any, Mapping
+
+from openapi_core.contrib.requests import (
+ RequestsOpenAPIRequest,
+ RequestsOpenAPIResponse,
+)
+from openapi_core.exceptions import OpenAPIError
+from openapi_core.templating.paths.exceptions import ServerNotFound
+from openapi_core.validation.exceptions import ValidationError
+from openapi_core.validation.response.exceptions import ResponseValidationError
+from requests import Response
+from robot.api import logger
+from robot.api.exceptions import Failure
+from robot.libraries.BuiltIn import BuiltIn
+
+from OpenApiLibCore.dto_base import resolve_schema
+from OpenApiLibCore.protocols import ResponseValidatorType
+from OpenApiLibCore.request_data import RequestData, RequestValues
+
+run_keyword = BuiltIn().run_keyword
+
+
+class ValidationLevel(str, Enum):
+ """The available levels for the response_validation parameter."""
+
+ DISABLED = "DISABLED"
+ INFO = "INFO"
+ WARN = "WARN"
+ STRICT = "STRICT"
+
+
+def perform_validated_request(
+ path: str,
+ status_code: int,
+ request_values: RequestValues,
+ original_data: Mapping[str, Any],
+) -> None:
+ response = run_keyword(
+ "authorized_request",
+ request_values.url,
+ request_values.method,
+ request_values.params,
+ request_values.headers,
+ request_values.json_data,
+ )
+ if response.status_code != status_code:
+ try:
+ response_json = response.json()
+ except Exception as _: # pylint: disable=broad-except
+ logger.info(
+ f"Failed to get json content from response. "
+ f"Response text was: {response.text}"
+ )
+ response_json = {}
+ if not response.ok:
+ if description := response_json.get("detail"):
+ pass
+ else:
+ description = response_json.get(
+ "message", "response contains no message or detail."
+ )
+ logger.error(f"{response.reason}: {description}")
+
+ logger.debug(
+ f"\nSend: {_json.dumps(request_values.json_data, indent=4, sort_keys=True)}"
+ f"\nGot: {_json.dumps(response_json, indent=4, sort_keys=True)}"
+ )
+ raise AssertionError(
+ f"Response status_code {response.status_code} was not {status_code}"
+ )
+
+ run_keyword("validate_response", path, response, original_data)
+
+ if request_values.method == "DELETE":
+ request_data: RequestData = run_keyword("get_request_data", path, "GET")
+ get_params = request_data.params
+ get_headers = request_data.headers
+ get_response = run_keyword(
+ "authorized_request", request_values.url, "GET", get_params, get_headers
+ )
+ if response.ok:
+ if get_response.ok:
+ raise AssertionError(
+ f"Resource still exists after deletion. Url was {request_values.url}"
+ )
+ # if the path supports GET, 404 is expected, if not 405 is expected
+ if get_response.status_code not in [404, 405]:
+ logger.warn(
+ f"Unexpected response after deleting resource: Status_code "
+ f"{get_response.status_code} was received after trying to get "
+ f"{request_values.url} after sucessfully deleting it."
+ )
+ elif not get_response.ok:
+ raise AssertionError(
+ f"Resource could not be retrieved after failed deletion. "
+ f"Url was {request_values.url}, status_code was {get_response.status_code}"
+ )
+
+
+def assert_href_to_resource_is_valid(
+ href: str, origin: str, base_url: str, referenced_resource: dict[str, Any]
+) -> None:
+ url = f"{origin}{href}"
+ path = url.replace(base_url, "")
+ request_data: RequestData = run_keyword("get_request_data", path, "GET")
+ params = request_data.params
+ headers = request_data.headers
+ get_response = run_keyword("authorized_request", url, "GET", params, headers)
+ assert get_response.json() == referenced_resource, (
+ f"{get_response.json()} not equal to original {referenced_resource}"
+ )
+
+
+def validate_response(
+ path: str,
+ response: Response,
+ response_validator: ResponseValidatorType,
+ server_validation_warning_logged: bool,
+ disable_server_validation: bool,
+ invalid_property_default_response: int,
+ response_validation: str,
+ openapi_spec: dict[str, Any],
+ original_data: Mapping[str, Any],
+) -> None:
+ if response.status_code == int(HTTPStatus.NO_CONTENT):
+ assert not response.content
+ return None
+
+ try:
+ _validate_response(
+ response=response,
+ response_validator=response_validator,
+ server_validation_warning_logged=server_validation_warning_logged,
+ disable_server_validation=disable_server_validation,
+ invalid_property_default_response=invalid_property_default_response,
+ response_validation=response_validation,
+ )
+ except OpenAPIError as exception:
+ raise Failure(
+ f"Response did not pass schema validation: {exception}"
+ ) from exception
+
+ request_method = response.request.method
+ if request_method is None:
+ logger.warn(
+ f"Could not validate response for path {path}; no method found "
+ f"on the request property of the provided response."
+ )
+ return None
+
+ response_spec = _get_response_spec(
+ path=path,
+ method=request_method,
+ status_code=response.status_code,
+ openapi_spec=openapi_spec,
+ )
+
+ content_type_from_response = response.headers.get("Content-Type", "unknown")
+ mime_type_from_response, _, _ = content_type_from_response.partition(";")
+
+ if not response_spec.get("content"):
+ logger.warn(
+ "The response cannot be validated: 'content' not specified in the OAS."
+ )
+ return None
+
+ # multiple content types can be specified in the OAS
+ content_types = list(response_spec["content"].keys())
+ supported_types = [
+ ct for ct in content_types if ct.partition(";")[0].endswith("json")
+ ]
+ if not supported_types:
+ raise NotImplementedError(
+ f"The content_types '{content_types}' are not supported. "
+ f"Only json types are currently supported."
+ )
+ content_type = supported_types[0]
+ mime_type = content_type.partition(";")[0]
+
+ if mime_type != mime_type_from_response:
+ raise ValueError(
+ f"Content-Type '{content_type_from_response}' of the response "
+ f"does not match '{mime_type}' as specified in the OpenAPI document."
+ )
+
+ json_response = response.json()
+ response_schema = resolve_schema(response_spec["content"][content_type]["schema"])
+
+ response_types = response_schema.get("types")
+ if response_types:
+ # In case of oneOf / anyOf there can be multiple possible response types
+ # which makes generic validation too complex
+ return None
+ response_type = response_schema.get("type", "undefined")
+ if response_type not in ["object", "array"]:
+ _validate_value_type(value=json_response, expected_type=response_type)
+ return None
+
+ if list_item_schema := response_schema.get("items"):
+ if not isinstance(json_response, list):
+ raise AssertionError(
+ f"Response schema violation: the schema specifies an array as "
+ f"response type but the response was of type {type(json_response)}."
+ )
+ type_of_list_items = list_item_schema.get("type")
+ if type_of_list_items == "object":
+ for resource in json_response:
+ run_keyword("validate_resource_properties", resource, list_item_schema)
+ else:
+ for item in json_response:
+ _validate_value_type(value=item, expected_type=type_of_list_items)
+ # no further validation; value validation of individual resources should
+ # be performed on the path for the specific resources
+ return None
+
+ run_keyword("validate_resource_properties", json_response, response_schema)
+ # ensure the href is valid if present in the response
+ if href := json_response.get("href"):
+ run_keyword("assert_href_to_resource_is_valid", href, json_response)
+ # every property that was sucessfully send and that is in the response
+ # schema must have the value that was send
+ if response.ok and response.request.method in ["POST", "PUT", "PATCH"]:
+ run_keyword("validate_send_response", response, original_data)
+ return None
+
+
+def validate_resource_properties(
+ resource: dict[str, Any], schema: dict[str, Any]
+) -> None:
+ schema_properties = schema.get("properties", {})
+ property_names_from_schema = set(schema_properties.keys())
+ property_names_in_resource = set(resource.keys())
+
+ if property_names_from_schema != property_names_in_resource:
+ # The additionalProperties property determines whether properties with
+ # unspecified names are allowed. This property can be boolean or an object
+ # (dict) that specifies the type of any additional properties.
+ additional_properties = schema.get("additionalProperties", True)
+ if isinstance(additional_properties, bool):
+ allow_additional_properties = additional_properties
+ allowed_additional_properties_type = None
+ else:
+ allow_additional_properties = True
+ allowed_additional_properties_type = additional_properties["type"]
+
+ extra_property_names = property_names_in_resource.difference(
+ property_names_from_schema
+ )
+ if allow_additional_properties:
+ # If a type is defined for extra properties, validate them
+ if allowed_additional_properties_type:
+ extra_properties = {
+ key: value
+ for key, value in resource.items()
+ if key in extra_property_names
+ }
+ _validate_type_of_extra_properties(
+ extra_properties=extra_properties,
+ expected_type=allowed_additional_properties_type,
+ )
+ # If allowed, validation should not fail on extra properties
+ extra_property_names = set()
+
+ required_properties = set(schema.get("required", []))
+ missing_properties = required_properties.difference(property_names_in_resource)
+
+ if extra_property_names or missing_properties:
+ extra = (
+ f"\n\tExtra properties in response: {extra_property_names}"
+ if extra_property_names
+ else ""
+ )
+ missing = (
+ f"\n\tRequired properties missing in response: {missing_properties}"
+ if missing_properties
+ else ""
+ )
+ raise AssertionError(
+ f"Response schema violation: the response contains properties that are "
+ f"not specified in the schema or does not contain properties that are "
+ f"required according to the schema."
+ f"\n\tReceived in the response: {property_names_in_resource}"
+ f"\n\tDefined in the schema: {property_names_from_schema}"
+ f"{extra}{missing}"
+ )
+
+
+def validate_send_response(
+ response: Response,
+ original_data: Mapping[str, Any],
+) -> None:
+ def validate_list_response(send_list: list[Any], received_list: list[Any]) -> None:
+ for item in send_list:
+ if item not in received_list:
+ raise AssertionError(
+ f"Received value '{received_list}' does "
+ f"not contain '{item}' in the {response.request.method} request."
+ f"\nSend: {_json.dumps(send_json, indent=4, sort_keys=True)}"
+ f"\nGot: {_json.dumps(response_data, indent=4, sort_keys=True)}"
+ )
+
+ def validate_dict_response(
+ send_dict: dict[str, Any], received_dict: dict[str, Any]
+ ) -> None:
+ for send_property_name, send_property_value in send_dict.items():
+ # sometimes, a property in the request is not in the response, e.g. a password
+ if send_property_name not in received_dict.keys():
+ continue
+ if send_property_value is not None:
+ # if a None value is send, the target property should be cleared or
+ # reverted to the default value (which cannot be specified in the
+ # openapi document)
+ received_value = received_dict[send_property_name]
+ # In case of lists / arrays, the send values are often appended to
+ # existing data
+ if isinstance(received_value, list):
+ validate_list_response(
+ send_list=send_property_value, received_list=received_value
+ )
+ continue
+
+ # when dealing with objects, we'll need to iterate the properties
+ if isinstance(received_value, dict):
+ validate_dict_response(
+ send_dict=send_property_value, received_dict=received_value
+ )
+ continue
+
+ assert received_value == send_property_value, (
+ f"Received value for {send_property_name} '{received_value}' does not "
+ f"match '{send_property_value}' in the {response.request.method} request."
+ f"\nSend: {_json.dumps(send_json, indent=4, sort_keys=True)}"
+ f"\nGot: {_json.dumps(response_data, indent=4, sort_keys=True)}"
+ )
+
+ if response.request.body is None:
+ logger.warn(
+ "Could not validate send response; the body of the request property "
+ "on the provided response was None."
+ )
+ return None
+ if isinstance(response.request.body, bytes):
+ send_json = _json.loads(response.request.body.decode("UTF-8"))
+ else:
+ send_json = _json.loads(response.request.body)
+
+ response_data = response.json()
+ # POST on /resource_type/{id}/array_item/ will return the updated {id} resource
+ # instead of a newly created resource. In this case, the send_json must be
+ # in the array of the 'array_item' property on {id}
+ send_path: str = response.request.path_url
+ response_path = response_data.get("href", None)
+ if response_path and send_path not in response_path:
+ property_to_check = send_path.replace(response_path, "")[1:]
+ if response_data.get(property_to_check) and isinstance(
+ response_data[property_to_check], list
+ ):
+ item_list: list[dict[str, Any]] = response_data[property_to_check]
+ # Use the (mandatory) id to get the POSTed resource from the list
+ [response_data] = [
+ item for item in item_list if item["id"] == send_json["id"]
+ ]
+
+ # incoming arguments are dictionaries, so they can be validated as such
+ validate_dict_response(send_dict=send_json, received_dict=response_data)
+
+ # In case of PATCH requests, ensure that only send properties have changed
+ if original_data:
+ for send_property_name, send_value in original_data.items():
+ if send_property_name not in send_json.keys():
+ assert send_value == response_data[send_property_name], (
+ f"Received value for {send_property_name} '{response_data[send_property_name]}' does not "
+ f"match '{send_value}' in the pre-patch data"
+ f"\nPre-patch: {_json.dumps(original_data, indent=4, sort_keys=True)}"
+ f"\nGot: {_json.dumps(response_data, indent=4, sort_keys=True)}"
+ )
+ return None
+
+
+def validate_response_using_validator(
+ request: RequestsOpenAPIRequest,
+ response: RequestsOpenAPIResponse,
+ response_validator: ResponseValidatorType,
+) -> None:
+ response_validator(request=request, response=response)
+
+
+def _validate_response(
+ response: Response,
+ response_validator: ResponseValidatorType,
+ server_validation_warning_logged: bool,
+ disable_server_validation: bool,
+ invalid_property_default_response: int,
+ response_validation: str,
+) -> None:
+ try:
+ validate_response_using_validator(
+ RequestsOpenAPIRequest(response.request),
+ RequestsOpenAPIResponse(response),
+ response_validator=response_validator,
+ )
+ except (ResponseValidationError, ServerNotFound) as exception:
+ error: BaseException | None = exception.__cause__
+ validation_errors: list[ValidationError] = getattr(error, "schema_errors", [])
+ if validation_errors:
+ error_message = "\n".join(
+ [
+ f"{list(getattr(error, 'schema_path', ''))}: {getattr(error, 'message', '')}"
+ for error in validation_errors
+ ]
+ )
+ else:
+ error_message = str(exception)
+
+ if isinstance(exception, ServerNotFound):
+ if not server_validation_warning_logged:
+ logger.warn(
+ f"ServerNotFound was raised during response validation. "
+ f"Due to this, no full response validation will be performed."
+ f"\nThe original error was: {error_message}"
+ )
+ server_validation_warning_logged = True
+ if disable_server_validation:
+ return
+
+ if response.status_code == invalid_property_default_response:
+ logger.debug(error_message)
+ return
+ if response_validation == ValidationLevel.STRICT:
+ logger.error(error_message)
+ raise exception
+ if response_validation == ValidationLevel.WARN:
+ logger.warn(error_message)
+ elif response_validation == ValidationLevel.INFO:
+ logger.info(error_message)
+
+
+def _validate_value_type(value: Any, expected_type: str) -> None:
+ type_mapping = {
+ "string": str,
+ "number": float,
+ "integer": int,
+ "boolean": bool,
+ "array": list,
+ "object": dict,
+ }
+ python_type = type_mapping.get(expected_type, None)
+ if python_type is None:
+ raise AssertionError(f"Validation of type '{expected_type}' is not supported.")
+ if not isinstance(value, python_type):
+ raise AssertionError(f"{value} is not of type {expected_type}")
+
+
+def _validate_type_of_extra_properties(
+ extra_properties: dict[str, Any], expected_type: str
+) -> None:
+ type_mapping = {
+ "string": str,
+ "number": float,
+ "integer": int,
+ "boolean": bool,
+ "array": list,
+ "object": dict,
+ }
+
+ python_type = type_mapping.get(expected_type, None)
+ if python_type is None:
+ logger.warn(
+ f"Additonal properties were not validated: "
+ f"type '{expected_type}' is not supported."
+ )
+ return
+
+ invalid_extra_properties = {
+ key: value
+ for key, value in extra_properties.items()
+ if not isinstance(value, python_type)
+ }
+ if invalid_extra_properties:
+ raise AssertionError(
+ f"Response contains invalid additionalProperties: "
+ f"{invalid_extra_properties} are not of type {expected_type}."
+ )
+
+
+def _get_response_spec(
+ path: str, method: str, status_code: int, openapi_spec: dict[str, Any]
+) -> dict[str, Any]:
+ method = method.lower()
+ status = str(status_code)
+ spec: dict[str, Any] = {**openapi_spec}["paths"][path][method]["responses"][status]
+ return spec
diff --git a/src/OpenApiLibCore/value_utils.py b/src/OpenApiLibCore/value_utils.py
index fdfeeeb..a2d818a 100644
--- a/src/OpenApiLibCore/value_utils.py
+++ b/src/OpenApiLibCore/value_utils.py
@@ -1,20 +1,24 @@
# mypy: disable-error-code=no-any-return
"""Utility module with functions to handle OpenAPI value types and restrictions."""
+
import base64
import datetime
from copy import deepcopy
-from logging import getLogger
from random import choice, randint, uniform
-from typing import Any, Callable
+from typing import Any, Callable, Iterable, Mapping, cast, overload
import faker
import rstr
+from robot.api import logger
+
+from OpenApiLibCore.annotations import JSON
-JSON = dict[str, "JSON"] | list["JSON"] | str | int | float | bool | None
-logger = getLogger(__name__)
+class Ignore:
+ """Helper class to flag properties to be ignored in data generation."""
-IGNORE = object()
+
+IGNORE = Ignore()
class LocalizedFaker:
@@ -107,7 +111,7 @@ def json_type_name_of_python_type(python_type: Any) -> str:
raise ValueError(f"No json type mapping for Python type {python_type} available.")
-def python_type_by_json_type_name(type_name: str) -> Any:
+def python_type_by_json_type_name(type_name: str) -> type:
"""Return the Python type based on the JSON type name."""
if type_name == "string":
return str
@@ -126,7 +130,7 @@ def python_type_by_json_type_name(type_name: str) -> Any:
raise ValueError(f"No Python type mapping for JSON type '{type_name}' available.")
-def get_valid_value(value_schema: dict[str, Any]) -> Any:
+def get_valid_value(value_schema: Mapping[str, Any]) -> JSON:
"""Return a random value that is valid under the provided value_schema."""
value_schema = deepcopy(value_schema)
@@ -156,10 +160,10 @@ def get_valid_value(value_schema: dict[str, Any]) -> Any:
def get_invalid_value(
- value_schema: dict[str, Any],
+ value_schema: Mapping[str, Any],
current_value: Any,
- values_from_constraint: list[Any] | None = None, # FIXME: default empty list?
-) -> Any:
+ values_from_constraint: Iterable[Any] = tuple(),
+) -> JSON | Ignore:
"""Return a random value that violates the provided value_schema."""
value_schema = deepcopy(value_schema)
@@ -180,7 +184,7 @@ def get_invalid_value(
values_from_constraint
and (
invalid_value := get_invalid_value_from_constraint(
- values_from_constraint=values_from_constraint,
+ values_from_constraint=list(values_from_constraint),
value_type=value_type,
)
)
@@ -212,7 +216,7 @@ def get_invalid_value(
return FAKE.uuid()
-def get_random_int(value_schema: dict[str, Any]) -> int:
+def get_random_int(value_schema: Mapping[str, Any]) -> int:
"""Generate a random int within the min/max range of the schema, if specified."""
# Use int32 integers if "format" does not specify int64
property_format = value_schema.get("format", "int32")
@@ -241,7 +245,7 @@ def get_random_int(value_schema: dict[str, Any]) -> int:
return randint(minimum, maximum)
-def get_random_float(value_schema: dict[str, Any]) -> float:
+def get_random_float(value_schema: Mapping[str, Any]) -> float:
"""Generate a random float within the min/max range of the schema, if specified."""
# Python floats are already double precision, so no check for "format"
minimum = value_schema.get("minimum")
@@ -289,7 +293,7 @@ def get_random_float(value_schema: dict[str, Any]) -> float:
return uniform(minimum, maximum)
-def get_random_string(value_schema: dict[str, Any]) -> bytes | str:
+def get_random_string(value_schema: Mapping[str, Any]) -> bytes | str:
"""Generate a random string within the min/max length in the schema, if specified."""
# if a pattern is provided, format and min/max length can be ignored
if pattern := value_schema.get("pattern"):
@@ -324,7 +328,7 @@ def fake_string(string_format: str) -> str:
return value
-def get_random_array(value_schema: dict[str, Any]) -> list[Any]:
+def get_random_array(value_schema: Mapping[str, Any]) -> list[JSON]:
"""Generate a list with random elements as specified by the schema."""
minimum = value_schema.get("minItems", 0)
maximum = value_schema.get("maxItems", 1)
@@ -338,8 +342,8 @@ def get_random_array(value_schema: dict[str, Any]) -> list[Any]:
def get_invalid_value_from_constraint(
- values_from_constraint: list[Any], value_type: str
-) -> Any:
+ values_from_constraint: list[JSON | Ignore], value_type: str
+) -> JSON | Ignore:
"""
Return a value of the same type as the values in the values_from_constraints that
is not in the values_from_constraints, if possible. Otherwise returns None.
@@ -347,7 +351,7 @@ def get_invalid_value_from_constraint(
# if IGNORE is in the values_from_constraints, the parameter needs to be
# ignored for an OK response so leaving the value at it's original value
# should result in the specified error response
- if IGNORE in values_from_constraint:
+ if any(map(lambda x: isinstance(x, Ignore), values_from_constraint)):
return IGNORE
# if the value is forced True or False, return the opposite to invalidate
if len(values_from_constraint) == 1 and value_type == "boolean":
@@ -362,46 +366,75 @@ def get_invalid_value_from_constraint(
values_from_constraint = deepcopy(values_from_constraint)
# for objects, keep the keys intact but update the values
if value_type == "object":
- valid_object = values_from_constraint.pop()
- invalid_object = {}
+ valid_object = cast(dict[str, JSON], values_from_constraint.pop())
+ invalid_object: dict[str, JSON] = {}
for key, value in valid_object.items():
python_type_of_value = type(value)
json_type_of_value = json_type_name_of_python_type(python_type_of_value)
- invalid_object[key] = get_invalid_value_from_constraint(
- values_from_constraint=[value],
- value_type=json_type_of_value,
+ invalid_value = cast(
+ JSON,
+ get_invalid_value_from_constraint(
+ values_from_constraint=[value],
+ value_type=json_type_of_value,
+ ),
)
+ invalid_object[key] = invalid_value
return invalid_object
# for arrays, update each value in the array to a value of the same type
if value_type == "array":
- valid_array = values_from_constraint.pop()
- invalid_array = []
+ valid_array = cast(list[JSON], values_from_constraint.pop())
+ invalid_array: list[JSON] = []
for value in valid_array:
python_type_of_value = type(value)
json_type_of_value = json_type_name_of_python_type(python_type_of_value)
- invalid_value = get_invalid_value_from_constraint(
- values_from_constraint=[value],
- value_type=json_type_of_value,
+ invalid_value = cast(
+ JSON,
+ get_invalid_value_from_constraint(
+ values_from_constraint=[value],
+ value_type=json_type_of_value,
+ ),
)
invalid_array.append(invalid_value)
return invalid_array
+ if value_type in ["integer", "number"]:
+ int_or_number_list = cast(list[int | float], values_from_constraint)
+ return get_invalid_int_or_number(values_from_constraint=int_or_number_list)
+
+ str_or_bytes_list = cast(list[str] | list[bytes], values_from_constraint)
+ invalid_value = get_invalid_str_or_bytes(values_from_constraint=str_or_bytes_list)
+ # None for empty string
+ return invalid_value if invalid_value else None
+
+
+def get_invalid_int_or_number(values_from_constraint: list[int | float]) -> int | float:
+ invalid_values = 2 * values_from_constraint
+ invalid_value = invalid_values.pop()
+ for value in invalid_values:
+ invalid_value = abs(invalid_value) + abs(value)
+ if not invalid_value:
+ invalid_value += 1
+ return invalid_value
+
+
+@overload
+def get_invalid_str_or_bytes(values_from_constraint: list[str]) -> str: ...
+
+
+@overload
+def get_invalid_str_or_bytes(values_from_constraint: list[bytes]) -> bytes: ...
+
+
+def get_invalid_str_or_bytes(values_from_constraint: list[Any]) -> Any:
invalid_values = 2 * values_from_constraint
invalid_value = invalid_values.pop()
- if value_type in ["integer", "number"]:
- for value in invalid_values:
- invalid_value = abs(invalid_value) + abs(value)
- if not invalid_value:
- invalid_value += 1
- return invalid_value
for value in invalid_values:
invalid_value = invalid_value + value
- # None for empty string
- return invalid_value if invalid_value else None
+ return invalid_value
-def get_invalid_value_from_enum(values: list[Any], value_type: str) -> Any:
+def get_invalid_value_from_enum(values: list[Any], value_type: str) -> JSON:
"""Return a value not in the enum by combining the enum values."""
if value_type == "string":
invalid_value: Any = ""
@@ -413,7 +446,7 @@ def get_invalid_value_from_enum(values: list[Any], value_type: str) -> Any:
# force creation of a new object since we will be modifying it
invalid_value = {**values[0]}
else:
- logger.warning(f"Cannot invalidate enum value with type {value_type}")
+ logger.warn(f"Cannot invalidate enum value with type {value_type}")
return None
for value in values:
# repeat each addition to ensure single-item enums are invalidated
@@ -435,7 +468,9 @@ def get_invalid_value_from_enum(values: list[Any], value_type: str) -> Any:
return invalid_value
-def get_value_out_of_bounds(value_schema: dict[str, Any], current_value: Any) -> Any:
+def get_value_out_of_bounds(
+ value_schema: Mapping[str, Any], current_value: JSON
+) -> JSON:
"""
Return a value just outside the value or length range if specified in the
provided schema, otherwise None is returned.
@@ -458,22 +493,24 @@ def get_value_out_of_bounds(value_schema: dict[str, Any], current_value: Any) ->
if (exclusive_maximum := value_schema.get("exclusiveMaximum")) is not None:
return exclusive_maximum
if value_type == "array":
+ current_list = cast(list[JSON], current_value)
if minimum := value_schema.get("minItems", 0) > 0:
- return current_value[0 : minimum - 1]
+ return current_list[0 : minimum - 1]
if (maximum := value_schema.get("maxItems")) is not None:
- invalid_value = current_value if current_value else ["x"]
+ invalid_value = current_list if current_list else ["x"]
while len(invalid_value) <= maximum:
- invalid_value.append(choice(invalid_value))
- return invalid_value
+ invalid_value.append(choice(invalid_value)) # pyright: ignore[reportArgumentType]
+ return invalid_value # type: ignore[unused-ignore]
if value_type == "string":
+ current_string = cast(str, current_value)
# if there is a minimum length, send 1 character less
if minimum := value_schema.get("minLength", 0):
- return current_value[0 : minimum - 1]
+ return current_string[0 : minimum - 1]
# if there is a maximum length, send 1 character more
if maximum := value_schema.get("maxLength"):
- invalid_value = current_value if current_value else "x"
+ invalid_string_value = current_string if current_string else "x"
# add random characters from the current value to prevent adding new characters
- while len(invalid_value) <= maximum:
- invalid_value += choice(invalid_value)
- return invalid_value
+ while len(invalid_string_value) <= maximum:
+ invalid_string_value += choice(invalid_string_value)
+ return invalid_string_value
return None
diff --git a/src/roboswag/core.py b/src/roboswag/core.py
index f47ee52..bec62e1 100644
--- a/src/roboswag/core.py
+++ b/src/roboswag/core.py
@@ -60,9 +60,9 @@ def send_request(
self.logger.log_request(resp)
self.logger.log_response(resp)
if status is not None:
- assert (
- resp.status_code == status
- ), f"Expected return status: {status} but received: {resp.status_code}"
+ assert resp.status_code == status, (
+ f"Expected return status: {status} but received: {resp.status_code}"
+ )
return resp
def post(self, *args, **kwargs):
diff --git a/tasks.py b/tasks.py
index 4c30ae1..1d098bd 100644
--- a/tasks.py
+++ b/tasks.py
@@ -6,8 +6,6 @@
from invoke.context import Context
from invoke.tasks import task
-# from OpenApiLibCore import openapi_libcore
-
ROOT = pathlib.Path(__file__).parent.resolve().as_posix()
VERSION = version("robotframework-openapitools")
@@ -79,6 +77,11 @@ def tests(context: Context) -> None:
def type_check(context: Context) -> None:
subprocess.run(f"mypy {ROOT}/src", shell=True, check=False)
subprocess.run(f"pyright {ROOT}/src", shell=True, check=False)
+ subprocess.run(
+ f"robotcode analyze code {ROOT}/tests/driver {ROOT}/tests/libcore",
+ shell=True,
+ check=False,
+ )
@task
diff --git a/tests/driver/suites/load_from_url.robot b/tests/driver/suites/load_from_url.robot
index e3dcac8..fc2d42b 100644
--- a/tests/driver/suites/load_from_url.robot
+++ b/tests/driver/suites/load_from_url.robot
@@ -16,6 +16,7 @@ Test Template Validate Test Endpoint Keyword
*** Test Cases ***
+# robotcode: ignore[ModelError, VariableNotReplaced]
Test Endpoint for ${method} on ${path} where ${status_code} is expected
diff --git a/tests/driver/suites/load_json.robot b/tests/driver/suites/load_json.robot
index ba1f74a..73181f5 100644
--- a/tests/driver/suites/load_json.robot
+++ b/tests/driver/suites/load_json.robot
@@ -16,10 +16,11 @@ Test Template Do Nothing
*** Test Cases ***
+# robotcode: ignore[ModelError, VariableNotReplaced]
OpenApiJson test for ${method} on ${path} where ${status_code} is expected
*** Keywords ***
Do Nothing
- [Arguments] ${path} ${method} ${status_code}
+ [Arguments] ${path} ${method} ${status_code} # robocop: off=unused-argument
No Operation
diff --git a/tests/driver/suites/load_yaml.robot b/tests/driver/suites/load_yaml.robot
index 0d7d133..87409a3 100644
--- a/tests/driver/suites/load_yaml.robot
+++ b/tests/driver/suites/load_yaml.robot
@@ -16,10 +16,11 @@ Test Template Do Nothing
*** Test Cases ***
+# robotcode: ignore[ModelError, VariableNotReplaced]
OpenApiYaml test for ${method} on ${path} where ${status_code} is expected
*** Keywords ***
Do Nothing
- [Arguments] ${path} ${method} ${status_code}
+ [Arguments] ${path} ${method} ${status_code} # robocop: off=unused-argument
No Operation
diff --git a/tests/driver/suites/test_mismatching_schemas.robot b/tests/driver/suites/test_mismatching_schemas.robot
index 799fc5e..5f2106c 100644
--- a/tests/driver/suites/test_mismatching_schemas.robot
+++ b/tests/driver/suites/test_mismatching_schemas.robot
@@ -26,6 +26,7 @@ Test Template Validate Test Endpoint Keyword
*** Test Cases ***
+# robotcode: ignore[ModelError, VariableNotReplaced]
Test Endpoint for ${method} on ${path} where ${status_code} is expected
diff --git a/tests/libcore/suites/test_auth_headers_and_token.robot b/tests/libcore/suites/test_auth_headers_and_token.robot
index da78cac..ae1cda0 100644
--- a/tests/libcore/suites/test_auth_headers_and_token.robot
+++ b/tests/libcore/suites/test_auth_headers_and_token.robot
@@ -20,7 +20,7 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Authorized Request With Security Token And Extra Headers
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${response}= Authorized Request
... url=${ORIGIN}/secret_message method=get headers=${request_data.headers}
Should Be Equal As Integers ${response.status_code} 200
@@ -36,7 +36,7 @@ Test Authorized Request With Security Token And Extra Headers
Test Set Security Token
Set Security Token another secret
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${response}= Authorized Request
... url=${ORIGIN}/secret_message method=get headers=${request_data.headers}
Should Be Equal As Integers ${response.status_code} 200
@@ -52,7 +52,7 @@ Test Set Security Token
Test Set Extra Headers
Set Extra Headers {"spam": "bacon"}
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${response}= Authorized Request
... url=${ORIGIN}/secret_message method=get headers=${request_data.headers}
Should Be Equal As Integers ${response.status_code} 200
@@ -70,7 +70,7 @@ Test Set Extra Headers
Test Set Basic Auth
Set Basic Auth username=Joe password=Jane
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${response}= Authorized Request
... url=${ORIGIN}/secret_message method=get headers=${request_data.headers}
Should Be Equal As Integers ${response.status_code} 200
@@ -88,7 +88,7 @@ Test Set Basic Auth
Test Set Auth
Set Auth auth=${DIGEST_AUTH}
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${response}= Authorized Request
... url=${ORIGIN}/secret_message method=get headers=${request_data.headers}
Should Be Equal As Integers ${response.status_code} 200
diff --git a/tests/libcore/suites/test_default_id_property_name.robot b/tests/libcore/suites/test_default_id_property_name.robot
index 245a396..1f23dda 100644
--- a/tests/libcore/suites/test_default_id_property_name.robot
+++ b/tests/libcore/suites/test_default_id_property_name.robot
@@ -12,10 +12,10 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
-Test Get Valid Id For Endpoint Returns Id For Id Defined In ID_MAPPING
- ${id}= Get Valid Id For Endpoint endpoint=/wagegroups method=post
+Test Get Valid Id For Path Returns Id For Id Defined In ID_MAPPING
+ ${id}= Get Valid Id For Path path=/wagegroups
Length Should Be ${id} 36
-Test Get Valid Id For Endpoint Raises For Resource With Non-default Id
+Test Get Valid Id For Path Raises For Resource With Non-default Id
Run Keyword And Expect Error Failed to get a valid id using*
- ... Get Valid Id For Endpoint endpoint=/available_employees method=get
+ ... Get Valid Id For Path path=/available_employees
diff --git a/tests/libcore/suites/test_ensure_in_use.robot b/tests/libcore/suites/test_ensure_in_use.robot
index a966fdd..aa0c782 100644
--- a/tests/libcore/suites/test_ensure_in_use.robot
+++ b/tests/libcore/suites/test_ensure_in_use.robot
@@ -14,19 +14,19 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Ensure In Use With Single Id In Url
- ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=get
+ ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
Ensure In Use url=${url} resource_relation=${ID_REFERENCE}
# Test Ensure In Use With Multiple Ids In Url
-# ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=get
+# ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
# Ensure In Use url=${url} resource_relation=${ID_REFERENCE}
Test Ensure In Use Raises When No Id In Url
- ${url}= Get Valid Url endpoint=/wagegroups method=post
+ ${url}= Get Valid Url path=/wagegroups
Run Keyword And Expect Error ValueError: The provided url*
... Ensure In Use url=${url} resource_relation=${ID_REFERENCE}
Test Ensure In Use Raises When Post Fails
- ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=get
+ ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
Run Keyword And Expect Error HTTPError: 405 Client Error*
... Ensure In Use url=${url} resource_relation=${INVALID_ID_REFERENCE}
diff --git a/tests/libcore/suites/test_faker_locale.robot b/tests/libcore/suites/test_faker_locale.robot
index 0392f06..b1c7f5d 100644
--- a/tests/libcore/suites/test_faker_locale.robot
+++ b/tests/libcore/suites/test_faker_locale.robot
@@ -13,6 +13,6 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Request Data For Schema With allOf
- ${request_data}= Get Request Data endpoint=/hypermedia method=post
+ ${request_data}= Get Request Data path=/hypermedia method=post
# this regex should match all characters in the simplified Chinese character set
Should Match Regexp ${request_data.dto.title} ^[\u4E00-\u9FA5]+$
diff --git a/tests/libcore/suites/test_get_ids_for_endpoint.robot b/tests/libcore/suites/test_get_ids_for_endpoint.robot
index 8d5212e..127bb86 100644
--- a/tests/libcore/suites/test_get_ids_for_endpoint.robot
+++ b/tests/libcore/suites/test_get_ids_for_endpoint.robot
@@ -14,14 +14,14 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Ids From Url That Returns Single Resource
- ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=post
+ ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
${ids}= Get Ids From Url url=${url}
Length Should Be item=${ids} length=1
Test Get Ids From Url That Returns List Of Resources
# Create an Employee resource so the returned list is not empty
- Get Valid Url endpoint=/employees/{employee_id} method=get
- ${url}= Get Valid Url endpoint=/employees method=get
+ Get Valid Url path=/employees/{employee_id}
+ ${url}= Get Valid Url path=/employees
${ids}= Get Ids From Url url=${url}
${number_of_ids}= Get Length item=${ids}
Should Be True $number_of_ids > 0
diff --git a/tests/libcore/suites/test_get_invalid_json_data.robot b/tests/libcore/suites/test_get_invalid_json_data.robot
index 12a89f0..4520175 100644
--- a/tests/libcore/suites/test_get_invalid_json_data.robot
+++ b/tests/libcore/suites/test_get_invalid_json_data.robot
@@ -14,7 +14,7 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Invalid Json Data Raises If Data Cannot Be Invalidated
- ${request_data}= Get Request Data endpoint=/ method=get
+ ${request_data}= Get Request Data path=/ method=get
Run Keyword And Expect Error ValueError: Failed to invalidate: no data_relations and empty schema.
... Get Invalid Json Data
... url=none
@@ -22,7 +22,7 @@ Test Get Invalid Json Data Raises If Data Cannot Be Invalidated
... status_code=999
... request_data=${request_data}
- ${request_data}= Get Request Data endpoint=/employees method=post
+ ${request_data}= Get Request Data path=/employees method=post
Run Keyword And Expect Error ValueError: No property can be invalidated to cause status_code 999
... Get Invalid Json Data
... url=none
@@ -31,7 +31,7 @@ Test Get Invalid Json Data Raises If Data Cannot Be Invalidated
... request_data=${request_data}
Test Get Invalid Json Data Based On Schema
- ${request_data}= Get Request Data endpoint=/events/ method=post
+ ${request_data}= Get Request Data path=/events/ method=post
Should Be Empty ${request_data.dto.get_relations_for_error_code(422)}
${invalid_json}= Get Invalid Json Data
... url=none
@@ -44,7 +44,7 @@ Test Get Invalid Json Data Based On Schema
Should Be Equal As Integers ${response.status_code} 422
Test Get Invalid Json Data For UniquePropertyValueConstraint
- ${request_data}= Get Request Data endpoint=/wagegroups method=post
+ ${request_data}= Get Request Data path=/wagegroups method=post
${invalid_json}= Get Invalid Json Data
... url=${ORIGIN}/wagegroups
... method=post
@@ -56,8 +56,8 @@ Test Get Invalid Json Data For UniquePropertyValueConstraint
Should Be Equal As Integers ${response.status_code} 418
Test Get Invalid Json Data For IdReference
- ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=delete
- ${request_data}= Get Request Data endpoint=/wagegroups/{wagegroup_id} method=delete
+ ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
+ ${request_data}= Get Request Data path=/wagegroups/{wagegroup_id} method=delete
${invalid_json}= Get Invalid Json Data
... url=${url}
... method=delete
@@ -69,8 +69,8 @@ Test Get Invalid Json Data For IdReference
Should Be Equal As Integers ${response.status_code} 406
Test Get Invalid Json Data For IdDependency
- ${url}= Get Valid Url endpoint=/employees method=post
- ${request_data}= Get Request Data endpoint=/employees method=post
+ ${url}= Get Valid Url path=/employees
+ ${request_data}= Get Request Data path=/employees method=post
${invalid_json}= Get Invalid Json Data
... url=${url}
... method=post
@@ -82,7 +82,7 @@ Test Get Invalid Json Data For IdDependency
Should Be Equal As Integers ${response.status_code} 451
Test Get Invalid Json Data For Dto With Other Relations
- ${request_data}= Get Request Data endpoint=/employees method=post
+ ${request_data}= Get Request Data path=/employees method=post
${invalid_json}= Get Invalid Json Data
... url=${ORIGIN}/employees
... method=post
@@ -94,8 +94,8 @@ Test Get Invalid Json Data For Dto With Other Relations
Should Be Equal As Integers ${response.status_code} 403
Test Get Invalid Json Data Can Invalidate Missing Optional Parameters
- ${url}= Get Valid Url endpoint=/employees/{emplyee_id} method=patch
- ${request_data}= Get Request Data endpoint=/employees/{emplyee_id} method=patch
+ ${url}= Get Valid Url path=/employees/{emplyee_id}
+ ${request_data}= Get Request Data path=/employees/{emplyee_id} method=patch
Evaluate ${request_data.dto.__dict__.clear()} is None
${invalid_json}= Get Invalid Json Data
... url=${url}
@@ -105,5 +105,5 @@ Test Get Invalid Json Data Can Invalidate Missing Optional Parameters
Should Not Be Equal ${invalid_json} ${request_data.dto.as_dict()}
${response}= Authorized Request
... url=${url} method=patch json_data=${invalid_json}
- ${expected_status_codes}= Create List ${403} ${422} ${451}
+ VAR @{expected_status_codes}= ${403} ${422} ${451}
Should Contain ${expected_status_codes} ${response.status_code}
diff --git a/tests/libcore/suites/test_get_invalidated_parameters.robot b/tests/libcore/suites/test_get_invalidated_parameters.robot
index 9d85f25..77f1f30 100644
--- a/tests/libcore/suites/test_get_invalidated_parameters.robot
+++ b/tests/libcore/suites/test_get_invalidated_parameters.robot
@@ -14,7 +14,7 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Invalidated Parameters Raises For Empty Parameters List
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
Evaluate ${request_data.parameters.clear()} is None
Run Keyword And Expect Error ValueError: No params or headers to invalidate.
... Get Invalidated Parameters
@@ -22,7 +22,7 @@ Test Get Invalidated Parameters Raises For Empty Parameters List
... request_data=${request_data}
Test Get Invalidated Parameters Raises For Mismatched Parameters List
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
Evaluate ${request_data.parameters.clear()} is None
Evaluate ${request_data.parameters.append({"name": "dummy"})} is None
Run Keyword And Expect Error ValueError: No parameter can be changed to cause status_code 401.
@@ -31,21 +31,21 @@ Test Get Invalidated Parameters Raises For Mismatched Parameters List
... request_data=${request_data}
Test Get Invalidated Parameters Raises For Status Code That Cannot Be Invalidated
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
Run Keyword And Expect Error ValueError: No relations to cause status_code 200 found.
... Get Invalidated Parameters
... status_code=200
... request_data=${request_data}
Test Get Invalidated Parameters Raises For Headers That Cannot Be Invalidated
- ${request_data}= Get Request Data endpoint=/ method=get
+ ${request_data}= Get Request Data path=/ method=get
Run Keyword And Expect Error ValueError: None of the query parameters and headers can be invalidated.
... Get Invalidated Parameters
... status_code=422
... request_data=${request_data}
Test Get Invalidated Parameters For Invalid Propery Default Response
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${invalidated}= Get Invalidated Parameters
... status_code=422
... request_data=${request_data}
@@ -53,14 +53,14 @@ Test Get Invalidated Parameters For Invalid Propery Default Response
Length Should Be ${secret_code} 36
Test Get Invalidated Parameters For PropertyValueConstraint
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${invalidated}= Get Invalidated Parameters
... status_code=401
... request_data=${request_data}
${secret_code}= Set Variable ${invalidated[1].get("secret-code")}
Should Be True int($secret_code) != 42
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${invalidated}= Get Invalidated Parameters
... status_code=403
... request_data=${request_data}
@@ -68,7 +68,7 @@ Test Get Invalidated Parameters For PropertyValueConstraint
Should Not Be Equal ${seal} ${NONE}
Test Get Invalidated Parameters Adds Optional Parameter If Not Provided
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
Evaluate ${request_data.headers.clear()} is None
${invalidated}= Get Invalidated Parameters
... status_code=422
@@ -77,7 +77,7 @@ Test Get Invalidated Parameters Adds Optional Parameter If Not Provided
Length Should Be ${headers} 1
Test Get Invalidated Parameters Adds Optional Parameter If treat_as_mandatory Is True
- ${request_data}= Get Request Data endpoint=/energy_label/{zipcode}/{home_number} method=get
+ ${request_data}= Get Request Data path=/energy_label/{zipcode}/{home_number} method=get
Evaluate ${request_data.params.clear()} is None
${invalidated}= Get Invalidated Parameters
... status_code=422
diff --git a/tests/libcore/suites/test_get_invalidated_url.robot b/tests/libcore/suites/test_get_invalidated_url.robot
index 5e59d4f..6860166 100644
--- a/tests/libcore/suites/test_get_invalidated_url.robot
+++ b/tests/libcore/suites/test_get_invalidated_url.robot
@@ -22,30 +22,29 @@ Test Get Invalidated Url Raises For Endpoint That Cannot Be Invalidated
... Get Invalidated Url valid_url=${ORIGIN}/employees
Test Get Invalidated Url For Endpoint Ending With Path Id
- ${url}= Get Valid Url endpoint=/employees/{employee_id} method=get
+ ${url}= Get Valid Url path=/employees/{employee_id}
${invalidated}= Get Invalidated Url valid_url=${url}
Should Not Be Equal ${url} ${invalidated}
Should Start With ${invalidated} http://localhost:8000/employees/
Test Get Invalidated Url For Endpoint Not Ending With Path Id
- ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id}/employees method=get
+ ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}/employees
${invalidated}= Get Invalidated Url valid_url=${url}
Should Not Be Equal ${url} ${invalidated}
Should Start With ${invalidated} http://localhost:8000/wagegroups/
Should End With ${invalidated} /employees
Test Get Invalidated Url For Endpoint With Multiple Path Ids
- ${url}= Get Valid Url endpoint=/energy_label/{zipcode}/{home_number} method=get
+ ${url}= Get Valid Url path=/energy_label/{zipcode}/{home_number}
${invalidated}= Get Invalidated Url valid_url=${url}
Should Not Be Equal ${url} ${invalidated}
Should Start With ${invalidated} http://localhost:8000/energy_label/1111AA/
Test Get Invalidated Url For PathPropertiesConstraint Invalid Value Status Code
- ${url}= Get Valid Url endpoint=/energy_label/{zipcode}/{home_number} method=get
+ ${url}= Get Valid Url path=/energy_label/{zipcode}/{home_number}
${invalidated}= Get Invalidated Url
... valid_url=${url}
... path=/energy_label/{zipcode}/{home_number}
- ... method=get
... expected_status_code=422
Should Not Be Equal ${url} ${invalidated}
Should Start With ${invalidated} http://localhost:8000/energy_label/0123AA
diff --git a/tests/libcore/suites/test_get_json_data_for_dto_class.robot b/tests/libcore/suites/test_get_json_data_for_dto_class.robot
index 7d2d04b..3f64431 100644
--- a/tests/libcore/suites/test_get_json_data_for_dto_class.robot
+++ b/tests/libcore/suites/test_get_json_data_for_dto_class.robot
@@ -13,35 +13,35 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Json Data For Dto Class With DefaultDto
- ${request_data}= Get Request Data endpoint=/wagegroups method=post
+ ${request_data}= Get Request Data path=/wagegroups method=post
Get Json Data For Dto Class
... schema=${request_data.dto_schema}
... dto_class=${DEFAULT_DTO}
... operation_id=dummy
Test Get Json Data For Dto Class With IGNORE Constrained
- ${request_data}= Get Request Data endpoint=/wagegroups method=post
+ ${request_data}= Get Request Data path=/wagegroups method=post
Get Json Data For Dto Class
... schema=${request_data.dto_schema}
... dto_class=${WAGEGROUP_DTO}
... operation_id=dummy
Test Get Json Data For Dto Class With Single DependantId
- ${request_data}= Get Request Data endpoint=/employees method=post
+ ${request_data}= Get Request Data path=/employees method=post
Get Json Data For Dto Class
... schema=${request_data.dto_schema}
... dto_class=${EMPLOYEE_DTO}
... operation_id=dummy
# Test Get Json Data For Dto Class With Multiple DependantIds
-# ${request_data}= Get Request Data endpoint=/employees method=post
+# ${request_data}= Get Request Data path=/employees method=post
# Get Json Data For Dto Class
# ... schema=${request_data.dto_schema}
# ... dto_class=${EMPLOYEE_DTO}
# ... operation_id=dummy
Test Get Json Data For Dto Class With Array And Object
- ${request_data}= Get Request Data endpoint=/events/ method=post
+ ${request_data}= Get Request Data path=/events/ method=post
Get Json Data For Dto Class
... schema=${request_data.dto_schema}
... dto_class=${DEFAULT_DTO}
diff --git a/tests/libcore/suites/test_get_json_data_with_conflict.robot b/tests/libcore/suites/test_get_json_data_with_conflict.robot
index b39b83f..52f3b98 100644
--- a/tests/libcore/suites/test_get_json_data_with_conflict.robot
+++ b/tests/libcore/suites/test_get_json_data_with_conflict.robot
@@ -13,7 +13,7 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Json Data With Conflict Raises For No UniquePropertyValueConstraint
- ${url}= Get Valid Url endpoint=/wagegroups method=post
+ ${url}= Get Valid Url path=/wagegroups
Run Keyword And Expect Error ValueError: No UniquePropertyValueConstraint*
... Get Json Data With Conflict
... url=${url}
@@ -22,8 +22,8 @@ Test Get Json Data With Conflict Raises For No UniquePropertyValueConstraint
... conflict_status_code=418
Test Get Json Data With Conflict For Post Request
- ${url}= Get Valid Url endpoint=/wagegroups method=post
- ${request_data}= Get Request Data endpoint=/wagegroups method=post
+ ${url}= Get Valid Url path=/wagegroups
+ ${request_data}= Get Request Data path=/wagegroups method=post
${invalid_data}= Get Json Data With Conflict
... url=${url}
... method=post
@@ -32,8 +32,8 @@ Test Get Json Data With Conflict For Post Request
Should Not Be Empty ${invalid_data}
Test Get Json Data With Conflict For Put Request
- ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=put
- ${request_data}= Get Request Data endpoint=/wagegroups/{wagegroup_id} method=put
+ ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
+ ${request_data}= Get Request Data path=/wagegroups/{wagegroup_id} method=put
${invalid_json}= Get Json Data With Conflict
... url=${url}
... method=put
@@ -44,8 +44,8 @@ Test Get Json Data With Conflict For Put Request
Should Be Equal As Integers ${response.status_code} 418
# Test Get Json Data With Conflict For Patch Request
-# ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=put
-# ${request_data}= Get Request Data endpoint=/wagegroups/{wagegroup_id} method=put
+# ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
+# ${request_data}= Get Request Data path=/wagegroups/{wagegroup_id} method=put
# ${invalid_json}= Get Json Data With Conflict
# ... url=${url}
# ... method=put
diff --git a/tests/libcore/suites/test_get_parameterized_endpoint_from_url.robot b/tests/libcore/suites/test_get_parameterized_endpoint_from_url.robot
index 976559e..e7e98a4 100644
--- a/tests/libcore/suites/test_get_parameterized_endpoint_from_url.robot
+++ b/tests/libcore/suites/test_get_parameterized_endpoint_from_url.robot
@@ -13,20 +13,20 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
-Test Get Parameterized Endpoint From Url Raises For Invalid Endpoint
+Test Get Parameterized Path From Url Raises For Invalid Endpoint
Run KeyWord And Expect Error ValueError: /dummy not found in paths section of the OpenAPI document.
- ... Get Parameterized Endpoint From Url url=${ORIGIN}/dummy
+ ... Get Parameterized Path From Url url=${ORIGIN}/dummy
-Test Get Parameterized Endpoint From Url With No Id
- ${url}= Get Valid Url endpoint=/events/ method=get
- ${endpoint}= Get Parameterized Endpoint From Url url=${url}
+Test Get Parameterized Path From Url With No Id
+ ${url}= Get Valid Url path=/events/
+ ${endpoint}= Get Parameterized Path From Url url=${url}
Should Be Equal ${endpoint} /events/
-Test Get Parameterized Endpoint From Url With Single Id
- ${url}= Get Valid Url endpoint=/employees/{employee_id} method=get
- ${endpoint}= Get Parameterized Endpoint From Url url=${url}
+Test Get Parameterized Path From Url With Single Id
+ ${url}= Get Valid Url path=/employees/{employee_id}
+ ${endpoint}= Get Parameterized Path From Url url=${url}
Should Be Equal ${endpoint} /employees/{employee_id}
-# Test Get Parameterized Endpoint From Url With Multiple Ids
-# ${url}= Get Valid Url endpoint=/events/ method=get
-# Get Parameterized Endpoint From Url url=${url}
+# Test Get Parameterized Path From Url With Multiple Ids
+# ${url}= Get Valid Url path=/events/
+# Get Parameterized Path From Url url=${url}
diff --git a/tests/libcore/suites/test_get_request_data.robot b/tests/libcore/suites/test_get_request_data.robot
index ab8d206..7b4ca28 100644
--- a/tests/libcore/suites/test_get_request_data.robot
+++ b/tests/libcore/suites/test_get_request_data.robot
@@ -1,4 +1,5 @@
*** Settings ***
+Library Collections
Library OpenApiLibCore
... source=${ORIGIN}/openapi.json
... origin=${ORIGIN}
@@ -13,9 +14,9 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Request Data For Invalid Method On Endpoint
- ${request_data}= Get Request Data endpoint=/events/ method=delete
- ${dict}= Create Dictionary
- ${list}= Create List
+ ${request_data}= Get Request Data path=/events/ method=delete
+ VAR &{dict}= &{EMPTY}
+ VAR @{list}= @{EMPTY}
Should Be Equal ${request_data.dto} ${DEFAULT_DTO()}
Should Be Equal ${request_data.dto_schema} ${dict}
Should Be Equal ${request_data.parameters} ${list}
@@ -24,25 +25,35 @@ Test Get Request Data For Invalid Method On Endpoint
Should Not Be True ${request_data.has_body}
Test Get Request Data For Endpoint With RequestBody
- ${request_data}= Get Request Data endpoint=/employees method=post
- ${dict}= Create Dictionary
- ${list}= Create List
- ${birthdays}= Create List 1970-07-07 1980-08-08 1990-09-09
- ${parttime_days}= Create List Monday Tuesday Wednesday Thursday Friday ${NONE}
+ ${request_data}= Get Request Data path=/employees method=post
+ VAR &{dict}= &{EMPTY}
+ VAR @{list}= @{EMPTY}
+ VAR @{birthdays}= 1970-07-07 1980-08-08 1990-09-09
+ VAR @{weekdays}= Monday Tuesday Wednesday Thursday Friday
Length Should Be ${request_data.dto.name} 36
Length Should Be ${request_data.dto.wagegroup_id} 36
Should Contain ${birthdays} ${request_data.dto.date_of_birth}
- Should Contain ${parttime_days} ${request_data.dto.parttime_day}
+ VAR ${generated_parttime_schedule}= ${request_data.dto.parttime_schedule}
+ IF $generated_parttime_schedule is not None
+ ${parttime_days}= Get From Dictionary ${generated_parttime_schedule} parttime_days
+ Should Be True 1 <= len($parttime_days) <= 5
+ FOR ${parttime_day} IN @{parttime_days}
+ ${weekday}= Get From Dictionary ${parttime_day} weekday
+ Should Contain ${weekdays} ${weekday}
+ ${available_hours}= Get From Dictionary ${parttime_day} available_hours
+ Should Be True 0 <= $available_hours < 8
+ END
+ END
Should Not Be Empty ${request_data.dto_schema}
Should Be Equal ${request_data.parameters} ${list}
Should Be Equal ${request_data.params} ${dict}
- &{expected_headers}= Create Dictionary content-type=application/json
+ VAR &{expected_headers}= content-type=application/json
Should Be Equal ${request_data.headers} ${expected_headers}
Should Be True ${request_data.has_body}
Test Get Request Data For Endpoint Without RequestBody But With DtoClass
- ${request_data}= Get Request Data endpoint=/wagegroups/{wagegroup_id} method=delete
- ${dict}= Create Dictionary
+ ${request_data}= Get Request Data path=/wagegroups/{wagegroup_id} method=delete
+ VAR &{dict}= &{EMPTY}
Should Be Equal As Strings ${request_data.dto} delete_wagegroup_wagegroups__wagegroup_id__delete()
Should Be Equal ${request_data.dto_schema} ${dict}
Should Not Be Empty ${request_data.parameters}
@@ -51,13 +62,13 @@ Test Get Request Data For Endpoint Without RequestBody But With DtoClass
Should Not Be True ${request_data.has_body}
# Test Get Request Data For Endpoint With RequestBody With Only Ignored Properties
-# ${request_data}= Get Request Data endpoint=/wagegroups/{wagegroup_id} method=delete
-# ${dict}= Create Dictionary
-# ${list}= Create List
+# ${request_data}= Get Request Data path=/wagegroups/{wagegroup_id} method=delete
+# VAR &{dict}= &{EMPTY}
+# VAR @{list}= @{EMPTY}
# Should Be Equal As Strings ${request_data.dto} delete_wagegroup_wagegroups__wagegroup_id__delete()
# Should Be Equal ${request_data.dto_schema} ${dict}
# Should Not Be Empty ${request_data.parameters}
# Should Be Equal ${request_data.params} ${dict}
-# &{expected_headers}= Create Dictionary content-type=application/json
+# VAR &{expected_headers}= content-type=application/json
# Should Be Equal ${request_data.headers} ${expected_headers}
# Should Be True ${request_data.has_body}
diff --git a/tests/libcore/suites/test_get_valid_id_for_endpoint.robot b/tests/libcore/suites/test_get_valid_id_for_endpoint.robot
index 9a7f321..e3d4c0c 100644
--- a/tests/libcore/suites/test_get_valid_id_for_endpoint.robot
+++ b/tests/libcore/suites/test_get_valid_id_for_endpoint.robot
@@ -13,28 +13,28 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
-Test Get Valid Id For Endpoint Raises For Endpoint Without Id In Path
+Test Get Valid Id For Path Raises For Endpoint Without Id In Path
Run Keyword And Expect Error Failed to get a valid id from*
- ... Get Valid Id For Endpoint endpoint=/events/ method=get
+ ... Get Valid Id For Path path=/events/
-Test Get Valid Id For Endpoint Raises For Endpoint With No Post Operation And No Resources
+Test Get Valid Id For Path Raises For Endpoint With No Post Operation And No Resources
Run Keyword And Expect Error Failed to get a valid id using GET on*
- ... Get Valid Id For Endpoint endpoint=/secret_message method=get
+ ... Get Valid Id For Path path=/secret_message
-Test Get Valid Id For Endpoint Returns Id For Resource Created By Post Operation
- ${id}= Get Valid Id For Endpoint endpoint=/wagegroups/{wagegroup_id} method=get
+Test Get Valid Id For Path Returns Id For Resource Created By Post Operation
+ ${id}= Get Valid Id For Path path=/wagegroups/{wagegroup_id}
Length Should Be ${id} 36
-Test Get Valid Id For Endpoint Returns Random Id From Array Endpoint With No Post Operation
- ${url}= Get Valid Url endpoint=/employees method=post
- ${request_data}= Get Request Data endpoint=/employees method=post
+Test Get Valid Id For Path Returns Random Id From Array Endpoint With No Post Operation
+ ${url}= Get Valid Url path=/employees
+ ${request_data}= Get Request Data path=/employees method=post
Authorized Request
... url=${url}
... method=post
... json_data=${request_data.get_required_properties_dict()}
- ${id}= Get Valid Id For Endpoint endpoint=/available_employees method=get
+ ${id}= Get Valid Id For Path path=/available_employees
Length Should Be ${id} 32
-# Test Get Valid Id For Endpoint By Href
+# Test Get Valid Id For Path By Href
-# Test Get Valid Id For Endpoint Raises For Post Operation That Returns Array
+# Test Get Valid Id For Path Raises For Post Operation That Returns Array
diff --git a/tests/libcore/suites/test_get_valid_url.robot b/tests/libcore/suites/test_get_valid_url.robot
index 3951b48..e9beea3 100644
--- a/tests/libcore/suites/test_get_valid_url.robot
+++ b/tests/libcore/suites/test_get_valid_url.robot
@@ -14,16 +14,16 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Valid Url Raises For Invalid Endpoint
Run Keyword And Expect Error ValueError: /dummy not found in paths section of the OpenAPI document.
- ... Get Valid Url endpoint=/dummy method=get
+ ... Get Valid Url path=/dummy
Test Get Valid Url With Unsupported Method
- ${url}= Get Valid Url endpoint=/events/ method=patch
+ ${url}= Get Valid Url path=/events/
Should Be Equal ${url} ${ORIGIN}/events/
Test Get Valid Url With Id
- ${url}= Get Valid Url endpoint=/wagegroups/{wagegroup_id} method=get
+ ${url}= Get Valid Url path=/wagegroups/{wagegroup_id}
Should Contain container=${url} item=${ORIGIN}/wagegroups/
Test Get Valid Url By PathPropertiesContraint
- ${url}= Get Valid Url endpoint=/energy_label/{zipcode}/{home_number} method=get
+ ${url}= Get Valid Url path=/energy_label/{zipcode}/{home_number}
Should Be Equal As Strings ${url} ${ORIGIN}/energy_label/1111AA/10
diff --git a/tests/libcore/suites/test_readonly.robot b/tests/libcore/suites/test_readonly.robot
index 2d3330f..385e81f 100644
--- a/tests/libcore/suites/test_readonly.robot
+++ b/tests/libcore/suites/test_readonly.robot
@@ -13,7 +13,7 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test ReadOnly Is Filtered From Request Data
- ${request_data}= Get Request Data endpoint=/api/location method=post
+ ${request_data}= Get Request Data path=/api/location method=post
${json_data}= Set Variable ${request_data.dto.as_dict()}
Should Not Contain ${json_data} id
Should Contain ${json_data} locationId
diff --git a/tests/libcore/suites/test_request_data_class.robot b/tests/libcore/suites/test_request_data_class.robot
index 37eb865..0fb1d5c 100644
--- a/tests/libcore/suites/test_request_data_class.robot
+++ b/tests/libcore/suites/test_request_data_class.robot
@@ -13,76 +13,77 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Has Optional Properties
- ${request_data}= Get Request Data endpoint=/employees method=get
+ ${request_data}= Get Request Data path=/employees method=get
Should Be Equal ${request_data.has_optional_properties} ${FALSE}
- ${request_data}= Get Request Data endpoint=/employees method=post
+ ${request_data}= Get Request Data path=/employees method=post
Should Be Equal ${request_data.has_optional_properties} ${TRUE}
Test Has Optional Params
- ${request_data}= Get Request Data endpoint=/available_employees method=get
+ ${request_data}= Get Request Data path=/available_employees method=get
Should Be Equal ${request_data.has_optional_params} ${FALSE}
- ${request_data}= Get Request Data endpoint=/energy_label/{zipcode}/{home_number} method=get
+ ${request_data}= Get Request Data path=/energy_label/{zipcode}/{home_number} method=get
Should Be Equal ${request_data.has_optional_params} ${TRUE}
Test Has Optional Headers
- ${request_data}= Get Request Data endpoint=/employees method=get
+ ${request_data}= Get Request Data path=/employees method=get
Should Be Equal ${request_data.has_optional_headers} ${FALSE}
- ${request_data}= Get Request Data endpoint=/ method=get
+ ${request_data}= Get Request Data path=/ method=get
Should Be Equal ${request_data.has_optional_headers} ${TRUE}
Test Params That Can Be Invalidated
- ${request_data}= Get Request Data endpoint=/available_employees method=get
+ ${request_data}= Get Request Data path=/available_employees method=get
${params}= Set Variable ${request_data.params_that_can_be_invalidated}
Should Contain ${params} weekday
- ${request_data}= Get Request Data endpoint=/energy_label/{zipcode}/{home_number} method=get
+ ${request_data}= Get Request Data path=/energy_label/{zipcode}/{home_number} method=get
${params}= Set Variable ${request_data.params_that_can_be_invalidated}
Should Contain ${params} extension
- ${request_data}= Get Request Data endpoint=/events/ method=get
+ ${request_data}= Get Request Data path=/events/ method=get
${params}= Set Variable ${request_data.params_that_can_be_invalidated}
Should Be Empty ${params}
Test Headers That Can Be Invalidated
- ${request_data}= Get Request Data endpoint=/ method=get
+ ${request_data}= Get Request Data path=/ method=get
${headers}= Set Variable ${request_data.headers_that_can_be_invalidated}
Should Be Empty ${headers}
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
${headers}= Set Variable ${request_data.headers_that_can_be_invalidated}
Should Contain ${headers} secret-code
Test Get Required Properties Dict
- ${request_data}= Get Request Data endpoint=/employees method=post
- Should Contain ${request_data.dto.as_dict()} parttime_day
+ ${request_data}= Get Request Data path=/employees method=post
+ Should Contain ${request_data.dto.as_dict()} parttime_schedule
Should Not Be Empty ${request_data.dto.name}
${required_properties}= Set Variable ${request_data.get_required_properties_dict()}
Should Contain ${required_properties} name
- # parttime_day is configured with treat_as_mandatory=True
- Should Contain ${required_properties} parttime_day
+ # parttime_schedule is configured with treat_as_mandatory=True
+ Should Contain ${required_properties} parttime_schedule
Test Get Required Params
- ${request_data}= Get Request Data endpoint=/available_employees method=get
+ ${request_data}= Get Request Data path=/available_employees method=get
Should Not Be Empty ${request_data.params.get("weekday")}
${required_params}= Set Variable ${request_data.get_required_params()}
Should Contain ${required_params} weekday
- ${request_data}= Get Request Data endpoint=/energy_label/{zipcode}/{home_number} method=get
+ ${request_data}= Get Request Data path=/energy_label/{zipcode}/{home_number} method=get
Should Contain ${request_data.params} extension
${required_params}= Set Variable ${request_data.get_required_params()}
- Should Be Empty ${required_params}
+ # extension is configured with treat_as_mandatory=True
+ Should Contain ${required_params} extension
Test Get Required Headers
- ${request_data}= Get Request Data endpoint=/secret_message method=get
+ ${request_data}= Get Request Data path=/secret_message method=get
Should Be Equal As Integers ${request_data.headers.get("secret-code")} 42
${required_headers}= Set Variable ${request_data.get_required_headers()}
Should Contain ${required_headers} secret-code
Should Not Contain ${required_headers} seal
- ${request_data}= Get Request Data endpoint=/ method=get
+ ${request_data}= Get Request Data path=/ method=get
Should Not Be Empty ${request_data.headers.get("name-from-header")}
Should Not Be Empty ${request_data.headers.get("title")}
${required_headers}= Set Variable ${request_data.get_required_headers()}
diff --git a/tests/libcore/suites/test_schema_variations.robot b/tests/libcore/suites/test_schema_variations.robot
index 201e2f0..45db8a1 100644
--- a/tests/libcore/suites/test_schema_variations.robot
+++ b/tests/libcore/suites/test_schema_variations.robot
@@ -12,14 +12,14 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Get Request Data For Schema With allOf
- ${request_data}= Get Request Data endpoint=/hypermedia method=post
- ${dict}= Create Dictionary
- ${list}= Create List
- ${list_of_dict}= Create List ${dict}
- ${expected_headers}= Create Dictionary content-type=application/hal+json
+ ${request_data}= Get Request Data path=/hypermedia method=post
+ VAR &{dict}= &{EMPTY}
+ VAR @{list}= @{EMPTY}
+ VAR &{expected_headers}= content-type=application/hal+json
Length Should Be ${request_data.dto.isan} 36
Length Should Be ${request_data.dto.published} 10
- Should Be Equal ${request_data.dto.tags} ${list_of_dict}
+ Length Should Be ${request_data.dto.tags} 1
+ Length Should Be ${request_data.dto.tags}[0] 36
Length Should Be ${request_data.dto_schema} 4
Length Should Be ${request_data.dto_schema.get("properties")} 4
Should Be Equal ${request_data.parameters} ${list}
diff --git a/tests/libcore/suites/test_validate_response.robot b/tests/libcore/suites/test_validate_response.robot
index e6307ea..0a41d2e 100644
--- a/tests/libcore/suites/test_validate_response.robot
+++ b/tests/libcore/suites/test_validate_response.robot
@@ -13,8 +13,8 @@ ${ORIGIN}= http://localhost:8000
*** Test Cases ***
Test Bool Response
- ${url}= Get Valid Url endpoint=/employees/{employee_id} method=patch
- ${request_data}= Get Request Data endpoint=/employees/{employee_id} method=patch
+ ${url}= Get Valid Url path=/employees/{employee_id}
+ ${request_data}= Get Request Data path=/employees/{employee_id} method=patch
${response}= Authorized Request
... url=${url}
... method=patch
diff --git a/tests/libcore/unittests/test_get_safe_key.py b/tests/libcore/unittests/test_get_safe_key.py
index 3878f6a..f22be52 100644
--- a/tests/libcore/unittests/test_get_safe_key.py
+++ b/tests/libcore/unittests/test_get_safe_key.py
@@ -1,7 +1,7 @@
# pylint: disable="missing-class-docstring", "missing-function-docstring"
import unittest
-from OpenApiLibCore.openapi_libcore import get_safe_key
+from OpenApiLibCore.data_generation.data_generation_core import get_safe_key
class TestGetSafeKey(unittest.TestCase):
diff --git a/tests/server/testserver.py b/tests/server/testserver.py
index d10a093..f6ea475 100644
--- a/tests/server/testserver.py
+++ b/tests/server/testserver.py
@@ -39,6 +39,15 @@ class WeekDay(str, Enum):
Friday = "Friday"
+class ParttimeDay(BaseModel):
+ weekday: WeekDay
+ available_hours: int = Field(4, ge=0, lt=8)
+
+
+class ParttimeSchedule(BaseModel):
+ parttime_days: list[ParttimeDay] = Field(..., min_length=1, max_length=5)
+
+
class Wing(str, Enum):
N = "North"
E = "East"
@@ -71,14 +80,14 @@ class EmployeeDetails(BaseModel):
employee_number: int
wagegroup_id: str
date_of_birth: datetime.date
- parttime_day: WeekDay | None = None
+ parttime_schedule: ParttimeSchedule | None = None
class Employee(BaseModel):
name: str
wagegroup_id: str
date_of_birth: datetime.date
- parttime_day: WeekDay | None = None
+ parttime_schedule: ParttimeSchedule | None = None
class EmployeeUpdate(BaseModel):
@@ -86,7 +95,7 @@ class EmployeeUpdate(BaseModel):
employee_number: int | None = None
wagegroup_id: str | None = None
date_of_birth: datetime.date | None = None
- parttime_day: WeekDay | None = None
+ parttime_schedule: ParttimeSchedule | None = None
WAGE_GROUPS: dict[str, WageGroup] = {}
@@ -280,10 +289,16 @@ def post_employee(employee: Employee) -> EmployeeDetails:
raise HTTPException(
status_code=403, detail="An employee must be at least 18 years old."
)
+ parttime_schedule = employee.parttime_schedule
+ if parttime_schedule is not None:
+ parttime_schedule = ParttimeSchedule.model_validate(parttime_schedule)
new_employee = EmployeeDetails(
identification=uuid4().hex,
+ name=employee.name,
employee_number=next(EMPLOYEE_NUMBERS),
- **employee.model_dump(),
+ wagegroup_id=employee.wagegroup_id,
+ date_of_birth=employee.date_of_birth,
+ parttime_schedule=parttime_schedule,
)
EMPLOYEES[new_employee.identification] = new_employee
return new_employee
@@ -349,12 +364,28 @@ def patch_employee(employee_id: str, employee: EmployeeUpdate) -> JSONResponse:
)
updated_employee = stored_employee_data.model_copy(update=employee_update_data)
+ if updated_employee.parttime_schedule is not None:
+ parttime_schedule = ParttimeSchedule.model_validate(
+ updated_employee.parttime_schedule
+ )
+ updated_employee.parttime_schedule = parttime_schedule
EMPLOYEES[employee_id] = updated_employee
return JSONResponse(content=True)
@app.get("/available_employees", status_code=200, response_model=list[EmployeeDetails])
def get_available_employees(weekday: WeekDay = Query(...)) -> list[EmployeeDetails]:
- return [
- e for e in EMPLOYEES.values() if getattr(e, "parttime_day", None) != weekday
- ]
+ available_employees: list[EmployeeDetails] = []
+ for employee in EMPLOYEES.values():
+ if not employee.parttime_schedule:
+ continue
+
+ weekday_availability = [
+ d.available_hours
+ for d in employee.parttime_schedule.parttime_days
+ if d.weekday == weekday
+ ]
+ if weekday_availability and weekday_availability[0] > 0:
+ available_employees.append(employee)
+
+ return available_employees
diff --git a/tests/user_implemented/custom_user_mappings.py b/tests/user_implemented/custom_user_mappings.py
index fe23d93..b7c95d6 100644
--- a/tests/user_implemented/custom_user_mappings.py
+++ b/tests/user_implemented/custom_user_mappings.py
@@ -60,6 +60,30 @@ def get_relations() -> list[ResourceRelation]:
return relations
+class ParttimeDayDto(Dto):
+ @staticmethod
+ def get_relations() -> list[ResourceRelation]:
+ relations: list[ResourceRelation] = [
+ PropertyValueConstraint(
+ property_name="weekday",
+ values=["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+ ),
+ ]
+ return relations
+
+
+class ParttimeScheduleDto(Dto):
+ @staticmethod
+ def get_relations() -> list[ResourceRelation]:
+ relations: list[ResourceRelation] = [
+ PropertyValueConstraint(
+ property_name="parttime_days",
+ values=[ParttimeDayDto],
+ ),
+ ]
+ return relations
+
+
class EmployeeDto(Dto):
@staticmethod
def get_relations() -> list[ResourceRelation]:
@@ -77,8 +101,8 @@ def get_relations() -> list[ResourceRelation]:
error_code=422,
),
PropertyValueConstraint(
- property_name="parttime_day",
- values=["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+ property_name="parttime_schedule",
+ values=[ParttimeScheduleDto],
treat_as_mandatory=True,
),
]