def test_reserved_characters_in_operation_name(swagger_20): # See GH-992 # When an API operation name contains `:` operation = APIOperation("/foo:bar", "GET", {}, swagger_20) case = operation.make_case() # Then it should not be truncated during API call assert case.as_requests_kwargs("/")["url"] == "/foo:bar"
def test_get_container_invalid_location(): operation = APIOperation( path="/users/{user_id}", method="get", schema=None, definition=OperationDefinition( raw={}, resolved={}, scope="", parameters=[ OpenAPI30Parameter({ "in": "query", "name": "code", "type": "integer" }), OpenAPI30Parameter({ "in": "query", "name": "user_id", "type": "integer" }), OpenAPI30Parameter({ "in": "query", "name": "common", "type": "integer" }), ], ), ) case = operation.make_case() with pytest.raises( ValueError, match= "Parameter `unknown` is not defined in API operation `GET /users/{user_id}`" ): get_container(case, None, "unknown")
def test_call(override, base_url, swagger_20): operation = APIOperation("/success", "GET", {}, swagger_20) case = operation.make_case() if override: response = case.call(base_url) else: operation.base_url = base_url response = case.call() assert response.status_code == 200 assert response.json() == {"success": True} with pytest.warns(None) as records: del response assert not records
def test_invalid_body_in_get(swagger_20): operation = APIOperation( path="/foo", method="GET", definition=OperationDefinition({}, {}, "foo", []), schema=swagger_20, body=PayloadAlternatives([ OpenAPI20Body( { "name": "attributes", "in": "body", "required": True, "schema": { "required": ["foo"], "type": "object", "properties": { "foo": { "type": "string" } } }, }, media_type="application/json", ) ]), ) with pytest.raises( InvalidSchema, match=r"^Body parameters are defined for GET request.$"): get_case_strategy(operation).example()
def test_case_partial_deepcopy(swagger_20): operation = APIOperation("/example/path", "GET", {}, swagger_20) original_case = Case( operation=operation, path_parameters={"test": "test"}, headers={"Content-Type": "application/json"}, cookies={"TOKEN": "secret"}, query={"a": 1}, body={"b": 1}, ) copied_case = original_case.partial_deepcopy() copied_case.operation.path = "/overwritten/path" copied_case.path_parameters["test"] = "overwritten" copied_case.headers["Content-Type"] = "overwritten" copied_case.cookies["TOKEN"] = "overwritten" copied_case.query["a"] = "overwritten" copied_case.body["b"] = "overwritten" assert original_case.operation.path == "/example/path" assert original_case.path_parameters["test"] == "test" assert original_case.headers["Content-Type"] == "application/json" assert original_case.cookies["TOKEN"] == "secret" assert original_case.query["a"] == 1 assert original_case.body["b"] == 1
def operation(): return APIOperation("/users/{user_id}", "GET", None, None, verbose_name="GET /users/{user_id}", base_url="http://127.0.0.1:8080/api")
def test_invalid_body_in_get_disable_validation(simple_schema): schema = schemathesis.from_dict(simple_schema, validate_schema=False) operation = APIOperation( path="/foo", method="GET", definition=OperationDefinition({}, {}, "foo", []), schema=schema, body=PayloadAlternatives( [ OpenAPI20Body( { "name": "attributes", "in": "body", "required": True, "schema": {"required": ["foo"], "type": "object", "properties": {"foo": {"type": "string"}}}, }, media_type="application/json", ) ] ), ) strategy = get_case_strategy(operation) @given(strategy) @settings(max_examples=1) def test(case): assert case.body is not None test()
def test_wrong_schema_type(check): schema = BaseSchema({}) # These checks should not be valid for some generic schema case = Case( operation=APIOperation("", "", None, verbose_name="", schema=schema)) with pytest.raises(TypeError): check(requests.Response(), case)
def test_from_case(swagger_20, base_url, expected): operation = APIOperation("/users/{name}", "GET", {}, swagger_20, base_url="http://127.0.0.1/api/v3") case = Case(operation, path_parameters={"name": "test"}) session = requests.Session() request = Request.from_case(case, session) assert request.uri == "http://127.0.0.1/api/v3/users/test"
def test_no_body_in_get(swagger_20): operation = APIOperation( path="/api/success", method="GET", definition=OperationDefinition({}, {}, "foo", []), schema=swagger_20, query=ParameterSet([ OpenAPI20Parameter({ "required": True, "in": "query", "type": "string", "name": "key", "x-example": "John", }) ]), ) strategies = operation.get_strategies_from_examples() assert len(strategies) == 1 assert strategies[0].example().body is NOT_SET
def test_deprecated_attribute(swagger_20): operation = APIOperation("/users/{name}", "GET", {}, swagger_20, base_url="http://127.0.0.1/api/v3") case = Case(operation) with pytest.warns(None) as records: assert case.endpoint == case.operation == operation assert str(records[0].message) == ( "Property `endpoint` is deprecated and will be removed in Schemathesis 4.0. Use `operation` instead." )
def test_as_requests_kwargs_override_user_agent(server, openapi2_base_url, swagger_20, headers, expected): operation = APIOperation("/success", "GET", {}, swagger_20, base_url=openapi2_base_url) original_headers = headers.copy() if headers is not None else headers case = operation.make_case(headers=headers) data = case.as_requests_kwargs(headers={"X-Key": "foo"}) assert data == { "headers": expected, "method": "GET", "params": None, "cookies": None, "url": f"http://127.0.0.1:{server['port']}/api/success", } assert case.headers == original_headers response = requests.request(**data) assert response.status_code == 200 assert response.json() == {"success": True}
def test_valid_headers(openapi2_base_url, swagger_20, definition): operation = APIOperation( "/api/success", "GET", definition=OperationDefinition({}, {}, "foo", []), schema=swagger_20, base_url=openapi2_base_url, headers=ParameterSet([OpenAPI20Parameter(definition)]), ) @given(case=get_case_strategy(operation)) @settings(suppress_health_check=[HealthCheck.filter_too_much, HealthCheck.too_slow], deadline=None, max_examples=10) def inner(case): case.call()
def test_as_requests_kwargs(override, server, base_url, swagger_20, converter): base_url = converter(base_url) operation = APIOperation("/success", "GET", {}, swagger_20) case = operation.make_case(cookies={"TOKEN": "secret"}) if override: data = case.as_requests_kwargs(base_url) else: operation.base_url = base_url data = case.as_requests_kwargs() assert data == { "headers": { "User-Agent": USER_AGENT }, "method": "GET", "params": None, "cookies": { "TOKEN": "secret" }, "url": f"http://127.0.0.1:{server['port']}/api/success", } response = requests.request(**data) assert response.status_code == 200 assert response.json() == {"success": True}
def test_invalid_request_body_definition(): # When a link defines `requestBody` for operation that does not accept one operation = APIOperation( path="/users/", method="get", verbose_name="GET /users/{user_id}", definition=ANY, schema=ANY, base_url=ANY, ) # Then a proper error should be triggered with pytest.raises(ValueError): Link(name="Link", operation=operation, parameters={}, request_body={"requestBody": { "foo": "bar" }})
def test_make_operation_body(body): # See GH-1069 # When `requestBody` is present in the link definition # And in the target operation operation = APIOperation( path="/users/", method="post", verbose_name="GET /users/{user_id}", definition=ANY, schema=ANY, base_url=ANY, body=PayloadAlternatives([body]), ) body = {"foo": "bar"} # Literal value link = Link( name="Link", operation=operation, parameters={}, request_body={"requestBody": body}, ) # Then it should be taken into account during creation a modified version of that operation new_operation = link.make_operation([ParsedData( {}, body=body)]) # Actual parsed data will contain the literal assert new_operation.body[0].definition["schema"] == {"enum": [body]}
(make_case(body="foo"), expected("json='foo'")), (make_case(body=1), expected("json=1")), (make_case(body=1.1), expected("json=1.1")), (make_case(body=True), expected("json=True")), (make_case(), expected()), (make_case(query={"a": 1}), expected("params={'a': 1}")), ), ) def test_get_code_to_reproduce(case, expected): assert case.get_code_to_reproduce( ) == expected, case.get_code_to_reproduce() def test_code_to_reproduce(): case = Case(APIOperation("/api/success", "GET", {}, base_url="http://127.0.0.1:1", schema=schema), body={"foo": 42}) request = requests.Request(**case.as_requests_kwargs()).prepare() code = case.get_code_to_reproduce(request=request) with pytest.raises(requests.exceptions.ConnectionError): eval(code) def test_code_to_reproduce_without_extra_args(): case = Case( APIOperation("/api/success", "GET", {}, base_url="http://0.0.0.0", schema=schema)) request = requests.Request(method="GET",
from schemathesis.models import APIOperation, Case, OperationDefinition from schemathesis.parameters import ParameterSet from schemathesis.specs.openapi.links import Link, get_container from schemathesis.specs.openapi.parameters import OpenAPI30Parameter from schemathesis.stateful import ParsedData, Stateful API_OPERATION = APIOperation( path="/users/{user_id}", method="get", definition=ANY, schema=ANY, base_url=ANY, path_parameters=ParameterSet( [ OpenAPI30Parameter({"in": "path", "name": "user_id", "schema": {"type": "integer"}}), ] ), query=ParameterSet( [ OpenAPI30Parameter({"in": "query", "name": "code", "schema": {"type": "integer"}}), OpenAPI30Parameter({"in": "query", "name": "user_id", "schema": {"type": "integer"}}), OpenAPI30Parameter({"in": "query", "name": "common", "schema": {"type": "integer"}}), ] ), ) LINK = Link( name="GetUserByUserId", operation=API_OPERATION, parameters={"path.user_id": "$response.body#/id", "query.user_id": "$response.body#/id"}, )
def make_operation(schema, **kwargs) -> APIOperation: return APIOperation("/users", "POST", definition=OperationDefinition({}, {}, "foo", []), schema=schema, **kwargs)
def test_path(swagger_20): operation = APIOperation("/users/{name}", "GET", {}, swagger_20) case = operation.make_case(path_parameters={"name": "test"}) assert case.formatted_path == "/users/test"
def make_case(**kwargs): operation = APIOperation("/api/success", "POST", {}, base_url="http://example.com", schema=schema) return Case(operation, media_type="application/json", **kwargs)
def test_case_repr(swagger_20, kwargs, expected): operation = APIOperation("/users/{name}", "GET", {}, swagger_20) case = operation.make_case(**kwargs) assert repr(case) == expected