def test_case_partial_deepcopy(swagger_20):
endpoint = Endpoint("/example/path", "GET", {}, swagger_20)
original_case = Case(
endpoint=endpoint,
path_parameters={"test": "test"},
headers={"Content-Type": "application/json"},
cookies={"TOKEN": "secret"},
query={"a": 1},
body={"b": 1},
form_data={"first": "John", "last": "Doe"},
)
copied_case = original_case.partial_deepcopy()
copied_case.endpoint.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"
copied_case.form_data["first"] = "overwritten"
assert original_case.endpoint.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
assert original_case.form_data["first"] == "John"
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 test_as_requests_kwargs(override, server, base_url, swagger_20, converter):
base_url = converter(base_url)
endpoint = Endpoint("/api/success", "GET", {}, swagger_20)
kwargs = {"endpoint": endpoint, "cookies": {"TOKEN": "secret"}}
if override:
case = Case(**kwargs)
data = case.as_requests_kwargs(base_url)
def test_from_case(swagger_20, base_url, expected):
endpoint = Endpoint("/users/{name}",
"GET", {},
swagger_20,
base_url="http://127.0.0.1/api/v3")
case = Case(endpoint, 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_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_strategy(swagger_20):
strategy = swagger_20["/v1/users"]["GET"].as_strategy()
assert isinstance(strategy, st.SearchStrategy)
assert strategy.example() == Case(path="/v1/users",
method="GET",
path_parameters={},
headers={},
cookies={},
query={},
body={},
form_data={})
def test_as_requests_kwargs_override_user_agent(server, openapi2_base_url,
swagger_20, headers, expected):
endpoint = Endpoint("/success",
"GET", {},
swagger_20,
base_url=openapi2_base_url)
original_headers = headers.copy() if headers is not None else headers
kwargs = {"endpoint": endpoint, "headers": headers}
case = Case(**kwargs)
data = case.as_requests_kwargs(headers={"X-Key": "foo"})
assert data == {
"headers": expected,
"json": None,
"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_call(override, base_url, swagger_20):
endpoint = Endpoint("/api/success", "GET", {}, swagger_20)
kwargs = {"endpoint": endpoint}
if override:
case = Case(**kwargs)
response = case.call(base_url)
def make_case(**kwargs):
operation = APIOperation("/api/success",
"POST", {},
base_url="http://example.com",
schema=schema)
return Case(operation, media_type="application/json", **kwargs)
endpoint = Endpoint("/users/{name}", "GET", {}, swagger_20)
case = Case(endpoint, path_parameters={"name": "test"})
assert case.formatted_path == "/users/test"
@pytest.mark.parametrize("override", (False, True))
@pytest.mark.parametrize("converter", (lambda x: x, lambda x: x + "/"))
def test_as_requests_kwargs(override, server, base_url, swagger_20, converter):
base_url = converter(base_url)
endpoint = Endpoint("/api/success", "GET", {}, swagger_20)
kwargs = {"endpoint": endpoint, "cookies": {"TOKEN": "secret"}}
if override:
case = Case(**kwargs)
data = case.as_requests_kwargs(base_url)
else:
case = Case(**kwargs)
endpoint.base_url = base_url
data = case.as_requests_kwargs()
assert data == {
"headers": None,
"json": None,
"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}
assert original_case.form_data["first"] == "John"
schema = schemathesis.from_path(SIMPLE_PATH)
ENDPOINT = Endpoint("/api/success",
"GET", {},
base_url="http://example.com",
schema=schema)
@pytest.mark.parametrize(
"case, expected",
(
# Body can be of any primitive type supported by Open API
(
Case(ENDPOINT, body={"test": 1}),
f"requests.get('http://example.com/api/success', "
f"headers={{'User-Agent': '{USER_AGENT}'}}, json={{'test': 1}})",
),
(
Case(ENDPOINT, body=["foo"]),
f"requests.get('http://example.com/api/success', headers={{'User-Agent': '{USER_AGENT}'}}, json=['foo'])",
),
(
Case(ENDPOINT, body="foo"),
f"requests.get('http://example.com/api/success', headers={{'User-Agent': '{USER_AGENT}'}}, json='foo')",
),
(
Case(ENDPOINT, body=1),
f"requests.get('http://example.com/api/success', headers={{'User-Agent': '{USER_AGENT}'}}, json=1)",
),
endpoint = Endpoint("/users/{name}", "GET", {}, swagger_20)
case = Case(endpoint, path_parameters={"name": "test"})
assert case.formatted_path == "/users/test"
@pytest.mark.parametrize("override", (False, True))
@pytest.mark.parametrize("converter", (lambda x: x, lambda x: x + "/"))
def test_as_requests_kwargs(override, server, base_url, swagger_20, converter):
base_url = converter(base_url)
endpoint = Endpoint("/success", "GET", {}, swagger_20)
kwargs = {"endpoint": endpoint, "cookies": {"TOKEN": "secret"}}
if override:
case = Case(**kwargs)
data = case.as_requests_kwargs(base_url)
else:
case = Case(**kwargs)
endpoint.base_url = base_url
data = case.as_requests_kwargs()
assert data == {
"headers": None,
"json": None,
"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_as_strategy(swagger_20):
operation = swagger_20["/users"]["GET"]
strategy = operation.as_strategy()
assert isinstance(strategy, st.SearchStrategy)
assert strategy.example() == Case(operation)
(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",
def test_as_strategy(swagger_20):
endpoint = swagger_20["/users"]["GET"]
strategy = endpoint.as_strategy()
assert isinstance(strategy, st.SearchStrategy)
assert strategy.example() == Case(endpoint)
def case():
return Case(ENDPOINT)
def test_path(swagger_20):
endpoint = Endpoint("/users/{name}", "GET", {}, swagger_20)
case = Case(endpoint, path_parameters={"name": "test"})
assert case.formatted_path == "/users/test"
def mock_case(create_endpoint):
return Case(endpoint=create_endpoint())
endpoint = Endpoint("/users/{name}", "GET", {}, swagger_20)
case = Case(endpoint, path_parameters={"name": "test"})
assert case.formatted_path == "/users/test"
@pytest.mark.parametrize("override", (False, True))
@pytest.mark.parametrize("converter", (lambda x: x, lambda x: x + "/"))
def test_as_requests_kwargs(override, server, base_url, swagger_20, converter):
base_url = converter(base_url)
endpoint = Endpoint("/success", "GET", {}, swagger_20)
kwargs = {"endpoint": endpoint, "cookies": {"TOKEN": "secret"}}
if override:
case = Case(**kwargs)
data = case.as_requests_kwargs(base_url)
else:
case = Case(**kwargs)
endpoint.base_url = base_url
data = case.as_requests_kwargs()
assert data == {
"headers": {
"User-Agent": USER_AGENT
},
"json": None,
"method": "GET",
"params": None,
"cookies": {
"TOKEN": "secret"
},
"url": f"http://127.0.0.1:{server['port']}/api/success",
}
response = requests.request(**data)
endpoint = Endpoint("/users/{name}", "GET", {}, swagger_20)
case = Case(endpoint, path_parameters={"name": "test"})
assert case.formatted_path == "/users/test"
@pytest.mark.parametrize("override", (False, True))
@pytest.mark.parametrize("converter", (lambda x: x, lambda x: x + "/"))
def test_as_requests_kwargs(override, server, base_url, swagger_20, converter):
base_url = converter(base_url)
endpoint = Endpoint("/api/success", "GET", {}, swagger_20)
kwargs = {"endpoint": endpoint, "cookies": {"TOKEN": "secret"}}
if override:
case = Case(**kwargs)
data = case.as_requests_kwargs(base_url)
else:
case = Case(**kwargs)
endpoint.base_url = base_url
data = case.as_requests_kwargs()
assert data == {
"headers": None,
"json": None,
"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}
(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(Endpoint("/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(
Endpoint("/api/success",
"GET", {},
base_url="http://0.0.0.0",
schema=schema))
request = requests.Request(method="GET",
def test_as_strategy(swagger_20):
strategy = swagger_20["/v1/users"]["GET"].as_strategy()
assert isinstance(strategy, st.SearchStrategy)
assert strategy.example() == Case(path="/v1/users", method="GET")
def make_case(**kwargs):
return Case(ENDPOINT, media_type="application/json", **kwargs)
def case():
return Case(API_OPERATION)
def test_as_strategy(swagger_20):
operation = swagger_20["/users"]["GET"]
strategy = operation.as_strategy()
assert isinstance(strategy, st.SearchStrategy)
assert strategy.example() == Case(
operation, data_generation_method=DataGenerationMethod.positive)
