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)