robotframework-schemathesislibrary 2.3.0

Robot Framework SchemathesisLibrary to automatically create test cases from API specifications.

Robot Framework SchemathesisLibrary

Robot Framework SchemathesisLibrary is a library build top of the Schemathesis. Schemathesis automatically generates thousands of test cases from your OpenAPI or GraphQL schema and finds edge cases that break your API.

SchemathesisLibrary uses DataDriver to create test cases from the Schemathesis Case object.

Installation

Install with pip, uv or any package manager that supports PyPi

pip install robotframework-schemathesislibrary

Keyword documentation

See keyword documentation for more details. A link older keyword documentation can be found from versions page

Usage

Test are automatically generated based your API specification, SchemathesisLibrary uses DataDriver internally, but you need to create template suite, so that DataDriver is able to create needed test for your test suite.

SchemathesisLibrary must be imported by url or path argument, which tell where the API specification can obtained. As like with Datadriver, there must be Test Template setting defined. The template keyword must take one argument, usually referred as ${case} and the template keyword must call Call And Validate keyword with the ${case} argument.

Example test suite:

*** Settings ***
Library             SchemathesisLibrary    url=http://127.0.0.1/openapi.json

Test Template       Wrapper


*** Test Cases ***
All Tests   # This test is deleted by DataDriver
    Wrapper    test_case_1


*** Keywords ***
Wrapper
    [Arguments]    ${case}
    Call And Validate    ${case}

Authentication

Dynamic token authentication

Library currently supports Schemathesis dynamic token authentication by the library import auth argument. The dynamic token generation class should follow the Schemathesis documentation. The only addition is the import. Importing the class must follow the Robot Framework library import rules , example if importing with filename, filename much match to the class name. Example if test case looks like:

*** Settings ***
Library             SchemathesisLibrary    url=http://127.0.0.1/openapi.json    auth=${CURDIR}/AuthExtension.py
Test Template       Wrapper

*** Test Cases ***
All Tests
    Wrapper    test_case_1

*** Keywords ***
Wrapper
    [Arguments]    ${case}
    Call And Validate    ${case}

And AuthExtension.py looks like

from base64 import b64encode

import schemathesis
from robot.api import logger


@schemathesis.auth()
class AuthExtension:
    def get(self, case, ctx):
        # Instead of hard coding secrets to class, it is better to get them dynamically.
        # Jenkins or GitHub secrets, Azure keyvault, or from somewhere which is appropriate
        # for your needs.
        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}")

Then with all API calls, will have basic auth set in the headers for all calls made to your API endpoint.

Schemathesis hook support

Library supports extending Schemathesis by defining hooks. Hooks allows users to customize how Schemathesis generates test data, validates responses, and handles requests through hooks, custom checks, and data generation strategies. For more details about Schemathesis hooks, refer to Schemathesis extending documentation: https://schemathesis.readthedocs.io/en/stable/guides/extending/

Example if there need to add custom header in each request, then it is possible to import library with hook:

*** Settings ***
Variables           authentication.py
Library             SchemathesisLibrary
...                     url=http://127.0.0.1/openapi.json
...                     hook=${CURDIR}/hook_filter.py

Test Template       Wrapper


*** Test Cases ***
All Tests
    Wrapper    test_case_1


*** Keywords ***
Wrapper
    [Arguments]    ${case}
    Call And Validate    ${case}    auth=${BASIC_AUTH_TUPLE}

And when hook_filter.py looks like:

import schemathesis


global_count_count = 0


@schemathesis.hook
def filter_query(ctx, query) -> bool:
    method = ctx.operation.method.lower().strip()
    if method == "put":
        global global_count_count
        global_count_count += 1
        if global_count_count > 2:
            return False
    return True

Then only two test with PUT request are generated.