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
