feat!: new schemathesis support

BREAKING CHANGE: Call* keywords have removed the auth argumement because
it  did not work properly anymore with latest Schemathesis versions.
Instead use auth argument in library import and implement a class with
Schemathesis auth section: https://schemathesis.readthedocs.io/en/stable/guides/auth/

Author: aaltat

.github/workflows/release.yml

@@ -49,7 +49,6 @@ jobs:
         uses: python-semantic-release/python-semantic-release@v10.4.1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          force: minor
       - name: Create release
         run: |
           uv version ${{ steps.release.outputs.version }}

atest/.DS_Store

@@ -0,0 +1,15 @@
+from base64 import b64encode
+
+import schemathesis
+from robot.api import logger
+
+
+@schemathesis.auth().apply_to(path_regex=r"/user/.+")
+class AuthExtension:
+    def get(self, case, ctx):
+        return b64encode("joulu:pukki".encode("utf-8")).decode("ascii")
+
+    def set(self, case, data, ctx):
+        case.headers = case.headers or {}
+        case.headers["Authorization"] = f"Basic {data}"
+        logger.debug(f"Updated headers for case: {case.operation.method} {case.operation.path}")

atest/library/AuthExtension.py

@@ -1,6 +1,5 @@
 *** Settings ***
-Variables           authentication.py
-Library             SchemathesisLibrary    url=http://127.0.0.1/openapi.json
+Library             SchemathesisLibrary    url=http://127.0.0.1/openapi.json    auth=${CURDIR}/AuthExtension.py
 
 Test Template       Wrapper
 
@@ -13,10 +12,5 @@ All Tests
 *** Keywords ***
 Wrapper
     [Arguments]    ${case}
-    IF    ${{'${case.path}'.startswith('/user')}}
-        VAR    ${auth}    ${BASIC_AUTH_TUPLE}
-    ELSE
-        VAR    ${auth}    ${None}
-    END
-    ${r} =    Call And Validate    ${case}    auth=${auth}
+    ${r} =    Call And Validate    ${case}
     Log    ${r.json()}

atest/library/all_cases_auth.robot

@@ -1,6 +1,5 @@
 *** Settings ***
-Variables           authentication.py
-Library             SchemathesisLibrary    url=http://127.0.0.1/openapi.json    max_examples=4    headers=${BASIC_AUTH_HEADERS}
+Library             SchemathesisLibrary    url=http://127.0.0.1/openapi.json    max_examples=4    auth=${CURDIR}/AuthExtension.py
 
 Test Template       Wrapper
 
@@ -13,11 +12,6 @@ All Tests
 *** Keywords ***
 Wrapper
     [Arguments]    ${case}
-    IF    ${{'${case.path}'.startswith('/user')}}
-        VAR    &{headers}    &{BASIC_AUTH_HEADERS}
-    ELSE
-        VAR    &{headers}
-    END
-    ${response} =    Call    ${case}    headers=${headers}
+    ${response} =    Call    ${case}
     Validate Response    ${case}    ${response}
     Log    ${response.json()}

atest/library/all_cases_call_and_validate_response.robot

@@ -1,6 +1,6 @@
 *** Settings ***
 Variables           authentication.py
-Library             SchemathesisLibrary    path=${CURDIR}/../specs/openapi.json
+Library             SchemathesisLibrary    path=${CURDIR}/../specs/openapi.json    auth=${CURDIR}/AuthExtension.py
 
 Test Template       Wrapper
 
@@ -14,7 +14,8 @@ All Tests
 Wrapper
     [Arguments]    ${case}
     IF    ${{'${case.path}'.startswith('/user')}}
-        VAR    &{headers}    &{BASIC_AUTH_HEADERS}
+        VAR    &{headers}    key1=value1    key2=value2
+        BuiltIn.Skip    Skipping test case for /user path
     ELSE
         VAR    &{headers}
     END

atest/library/all_cases_from_file.robot

@@ -103,3 +103,7 @@ ignore = [
 
 [tool.ruff.format]
 quote-style = "double"
+
+[tool.mypy]
+python_version = "3.10"
+files = "src/SchemathesisLibrary"

pyproject.toml

@@ -11,69 +11,25 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from DataDriver import DataDriver  # type: ignore
-from DataDriver.AbstractReaderClass import AbstractReaderClass  # type: ignore
-from DataDriver.ReaderConfig import TestCaseData  # type: ignore
-from hypothesis import HealthCheck, Phase, Verbosity, given, settings
-from hypothesis import strategies as st
 from robot.api import logger
 from robot.api.deco import keyword
 from robot.result.model import TestCase as ResultTestCase  # type: ignore
 from robot.result.model import TestSuite as ResultTestSuite  # type: ignore
 from robot.running.model import TestCase, TestSuite  # type: ignore
 from robotlibcore import DynamicCore  # type: ignore
-from schemathesis import Case, openapi
+from schemathesis import Case
 from schemathesis.core import NotSet
-from schemathesis.core.result import Ok
 from schemathesis.core.transport import Response
 
-__version__ = "0.53.0"
+from .schemathesisreader import Options, SchemathesisReader
 
+if TYPE_CHECKING:
+    from pathlib import Path
 
-@dataclass
-class Options:
-    max_examples: int
-    headers: dict[str, Any] | None = None
-    path: "Path|None" = None
-    url: "str|None" = None
-
-
-class SchemathesisReader(AbstractReaderClass):
-    options: "Options|None" = None
-
-    def get_data_from_source(self) -> list[TestCaseData]:
-        if not self.options:
-            raise ValueError("Options must be set before calling get_data_from_source.")
-        url = self.options.url
-        path = self.options.path
-        if path and not Path(path).is_file():
-            raise ValueError(f"Provided path '{path}' is not a valid file.")
-        if path:
-            schema = openapi.from_path(path)
-        elif url:
-            headers = self.options.headers or {}
-            schema = openapi.from_url(url, headers=headers)
-        else:
-            raise ValueError("Either 'url' or 'path' must be provided to SchemathesisLibrary.")
-        all_cases: list[TestCaseData] = []
-        for op in schema.get_all_operations():
-            if isinstance(op, Ok):
-                # NOTE: (dd): `as_strategy` also accepts GenerationMode
-                #             It could be used to produce positive / negative tests
-                strategy = op.ok().as_strategy().map(from_case)  # type: ignore
-                add_examples(strategy, all_cases, self.options.max_examples)  # type: ignore
-        return all_cases
-
-
-def from_case(case: Case) -> TestCaseData:
-    return TestCaseData(
-        test_case_name=f"{case.operation.label} - {case.id}",
-        arguments={"${case}": case},
-    )
+__version__ = "0.53.0"
 
 
 class SchemathesisLibrary(DynamicCore):
@@ -121,17 +77,21 @@ def __init__(
         max_examples: int = 5,
         path: "Path|None" = None,
         url: "str|None" = None,
+        auth: str | None = None,
     ) -> None:
         """The SchemathesisLibrary can be initialized with the following arguments:
 
         | =Argument=                        | =Description= |
-        | `headers`                         | Optional HTTP headers to be used schema is downloaded from `url`. |
+        | `headers`                         | Optional HTTP headers to be used when schema is downloaded from `url`. |
         | `max_examples`                    | Maximum number of examples to generate for each operation. Default is 5. |
         | `path`                            | Path to the OpenAPI schema file. Using either `path` or `url` is mandatory. |
         | `url`                             | URL where the OpenAPI schema can be downloaded. |
+        | `auth`                            | Optional authentication class to be used passed for Schemathesis authentication when test cases are executed. |
         """
         self.ROBOT_LIBRARY_LISTENER = self
-        SchemathesisReader.options = Options(headers=headers, max_examples=max_examples, path=path, url=url)
+        SchemathesisReader.options = Options(
+            headers=headers, max_examples=max_examples, path=path, url=url, auth=auth
+        )
         self.data_driver = DataDriver(reader_class=SchemathesisReader)
         DynamicCore.__init__(self, [])
 
@@ -146,9 +106,8 @@ def call_and_validate(
         self,
         case: Case,
         *,
-        auth: "Any|None" = None,
-        base_url: "str|None" = None,
-        headers: "dict[str, Any]|None" = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
     ) -> Response:
         """Call and validate a Schemathesis case.
 
@@ -157,7 +116,7 @@ def call_and_validate(
         """
         self.info(f"Case: {case.path} | {case.method} | {case.path_parameters}")
         self._log_case(case, headers)
-        response = case.call_and_validate(base_url=base_url, headers=headers, auth=auth)
+        response = case.call_and_validate(base_url=base_url, headers=headers)
         self._log_request(response)
         self.debug(f"Response: {response.headers} | {response.status_code} | {response.text}")
         return response
@@ -167,9 +126,8 @@ def call(
         self,
         case: Case,
         *,
-        auth: "Any|None" = None,
-        base_url: "str|None" = None,
-        headers: "dict[str, Any]|None" = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
     ) -> Response:
         """Call a Schemathesis case without validation.
 
@@ -182,7 +140,7 @@ def call(
         """
         self.info(f"Calling case: {case.path} | {case.method} | {case.path_parameters}")
         self._log_case(case)
-        response = case.call(base_url=base_url, headers=headers, auth=auth)
+        response = case.call(base_url=base_url, headers=headers)
         self._log_request(response)
         return response
 
@@ -222,19 +180,3 @@ def _log_request(self, resposen: Response) -> None:
             f"Request: {resposen.request.method} {resposen.request.url} "
             f"headers: {resposen.request.headers!r} body: {resposen.request.body!r}"
         )
-
-
-def add_examples(strategy: st.SearchStrategy, container: list[TestCaseData], max_examples: int) -> None:
-    @given(strategy)
-    @settings(
-        database=None,
-        max_examples=max_examples,
-        deadline=None,
-        verbosity=Verbosity.quiet,
-        phases=(Phase.generate,),
-        suppress_health_check=list(HealthCheck),
-    )
-    def example_generating_inner_function(ex: Any) -> None:
-        container.append(ex)
-
-    example_generating_inner_function()

src/SchemathesisLibrary/__init__.py

@@ -0,0 +1,96 @@
+# Copyright 2025-     Tatu Aalto
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from DataDriver.AbstractReaderClass import AbstractReaderClass  # type: ignore
+from DataDriver.ReaderConfig import TestCaseData  # type: ignore
+from hypothesis import HealthCheck, Phase, Verbosity, given, settings
+from hypothesis import strategies as st
+from robot.api import logger
+from robot.utils.importer import Importer  # type: ignore
+from schemathesis import Case, openapi
+from schemathesis.core.result import Ok
+
+
+@dataclass
+class Options:
+    max_examples: int
+    headers: dict[str, Any] | None = None
+    path: "Path|None" = None
+    url: str | None = None
+    auth: str | None = None
+
+
+class SchemathesisReader(AbstractReaderClass):
+    options: "Options|None" = None
+
+    def get_data_from_source(self) -> list[TestCaseData]:
+        if not self.options:
+            raise ValueError("Options must be set before calling get_data_from_source.")
+        url = self.options.url
+        path = self.options.path
+        if path and not Path(path).is_file():
+            raise ValueError(f"Provided path '{path}' is not a valid file.")
+        if path:
+            schema = openapi.from_path(path)
+        elif url:
+            headers = self.options.headers or {}
+            schema = openapi.from_url(url, headers=headers)
+        else:
+            raise ValueError("Either 'url' or 'path' must be provided to SchemathesisLibrary.")
+        all_cases: list[TestCaseData] = []
+        if self.options.auth:
+            import_extensions(self.options.auth)
+            logger.info(f"Using auth extension from: {self.options.auth}")
+
+        for op in schema.get_all_operations():
+            if isinstance(op, Ok):
+                # NOTE: (dd): `as_strategy` also accepts GenerationMode
+                #             It could be used to produce positive / negative tests
+                strategy = op.ok().as_strategy().map(from_case)  # type: ignore
+                add_examples(strategy, all_cases, self.options.max_examples)  # type: ignore
+        return all_cases
+
+
+def from_case(case: Case) -> TestCaseData:
+    return TestCaseData(
+        test_case_name=f"{case.operation.label} - {case.id}",
+        arguments={"${case}": case},
+    )
+
+
+def add_examples(strategy: st.SearchStrategy, container: list[TestCaseData], max_examples: int) -> None:
+    @given(strategy)
+    @settings(
+        database=None,
+        max_examples=max_examples,
+        deadline=None,
+        verbosity=Verbosity.quiet,
+        phases=(Phase.generate,),
+        suppress_health_check=list(HealthCheck),
+    )
+    def example_generating_inner_function(ex: Any) -> None:
+        container.append(ex)
+
+    example_generating_inner_function()
+
+
+def import_extensions(library: str | Path) -> Any:
+    """Import any extensions for SchemathesisLibrary."""
+    importer = Importer("test library")
+    lib = importer.import_module(library)
+    logger.info(f"Imported extension module: {lib}")
+    return lib

src/SchemathesisLibrary/schemathesisreader.py

@@ -153,7 +153,7 @@ def spec_file(ctx):
 
 
 @task(pre=[test_app, spec_file])
-def atest(ctx):
+def atest(ctx, suite: str | None = None):
     """Run acceptance tests."""
     args = [
         "uv",
@@ -175,6 +175,32 @@ def atest(ctx):
     ctx.run(" ".join(args))
 
 
+@task(pre=[test_app, spec_file])
+def atest_lib(ctx, suite: str | None = None):
+    """Run library tests."""
+    args = [
+        "uv",
+        "run",
+        "robot",
+        "--loglevel",
+        "DEBUG:INFO",
+        "--pythonpath",
+        "./src",
+        "--outputdir",
+        ATEST_OUTPUT_DIR_LIB.as_posix(),
+    ]
+    if suite:
+        args.append(f"--suite")
+        args.append(suite)
+    args.append("atest/library")
+    shutil.rmtree(ATEST_OUTPUT_DIR, ignore_errors=True)
+    shutil.rmtree(ATEST_OUTPUT_DIR_LIB, ignore_errors=True)
+    ATEST_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    ATEST_OUTPUT_DIR_LIB.mkdir(parents=True, exist_ok=True)
+    print(f"Running {args}")
+    ctx.run(" ".join(args))
+
+
 @task
 def clean(ctx):
     """Clean up the output and dist directories."""