alanorth/dspace-statistics-api
1
0
Fork 0
mirror of https://github.com/ilri/dspace-statistics-api.git synced 2024-12-26 06:24:29 +01:00
Code Releases Activity
d7375d678f
dspace-statistics-api/tests/test_api_collections.py

380 lines
13 KiB
Python
Raw Normal View History

Add SPDX short license identifier to all Python files See: https://spdx.github.io/spdx-spec/appendix-V-using-SPDX-short-identifiers-in-source-files/
2021-03-22 12:42:42 +01:00
# SPDX-License-Identifier: GPL-3.0-only
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
import json
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
from unittest.mock import patch
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests: Sort imports with isort
2021-01-14 13:12:59 +01:00
import pytest
from falcon import testing
Changes for Falcon 3.0.0 Mostly it seems we just need to use resp.text instead of resp.body, including in falcon-swagger-ui (I forked the upstream one to make this change). See: https://falcon.readthedocs.io/en/latest/changes/3.0.0.html
2021-03-21 09:32:58 +01:00
from dspace_statistics_api.app import app
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
@pytest.fixture
def client():
Changes for Falcon 3.0.0 Mostly it seems we just need to use resp.text instead of resp.body, including in falcon-swagger-ui (I forked the upstream one to make this change). See: https://falcon.readthedocs.io/en/latest/changes/3.0.0.html
2021-03-21 09:32:58 +01:00
return testing.TestClient(app)
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_get_collection(client):
"""Test requesting a single collection."""
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_get("/collection/8ea4b611-1f59-4d4e-b78d-a9921a72cfe7")
tests/test_api.py: Use response.text instead of content Falcon's response content is raw bytes, while its text is a string. Let's use the latter so we can use json.loads() in Python 3.5, 3.6, and 3.7 with the same code. See: https://falcon.readthedocs.io/en/stable/api/testing.html
2018-11-11 16:01:17 +01:00
response_doc = json.loads(response.text)
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests/test_api.py: Format with black
2019-12-14 11:39:58 +01:00
assert isinstance(response_doc["downloads"], int)
tests/test_api.py: Use UUID DSpace 6+ uses a UUID for item identifiers instead of an integer so we need to adapt our tests accordingly. The Python UUID object must be cast to a string to use it elsewhere in the code.
2020-03-02 10:10:41 +01:00
assert isinstance(response_doc["id"], str)
tests/test_api.py: Format with black
2019-12-14 11:39:58 +01:00
assert isinstance(response_doc["views"], int)
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
assert response.status_code == 200
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_get_missing_collection(client):
"""Test requesting a single non-existing collection."""
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_get("/collection/508abe0a-689f-402e-885d-2f6b02e7a39c")
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
assert response.status_code == 404
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_get_collections(client):
"""Test requesting 100 collections."""
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_get("/collections", query_string="limit=100")
tests/test_api.py: Use response.text for all json.loads() This allows the code to work in Python 3.5 as well as 3.6+.
2018-11-11 16:05:31 +01:00
response_doc = json.loads(response.text)
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests/test_api.py: Format with black
2019-12-14 11:39:58 +01:00
assert isinstance(response_doc["currentPage"], int)
assert isinstance(response_doc["totalPages"], int)
assert isinstance(response_doc["statistics"], list)
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
assert response.status_code == 200
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_get_collections_invalid_limit(client):
"""Test requesting 100 collections with an invalid limit parameter."""
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_get("/collections", query_string="limit=101")
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
assert response.status_code == 400
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_get_collections_invalid_page(client):
"""Test requesting 100 collections with an invalid page parameter."""
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_get("/collections", query_string="page=-1")
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
assert response.status_code == 400
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
@pytest.mark.xfail
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_dateFrom(client):
"""Test POSTing a request to /collections with a valid dateFrom parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"dateFrom": "2020-01-01T00:00:00Z",
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 100
assert response.json["currentPage"] == 0
assert isinstance(response.json["totalPages"], int)
assert len(response.json["statistics"]) == 2
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
assert isinstance(response.json["statistics"][1]["views"], int)
assert isinstance(response.json["statistics"][1]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_dateFrom_mocked(client):
"""Mock test POSTing a request to /collections with a valid dateFrom parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"dateFrom": "2020-01-01T00:00:00Z",
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
get_views_return_value = {
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 21,
"260548c8-fda4-4dc8-a979-03495753cdd5": 0,
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
}
get_downloads_return_value = {
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 575,
"260548c8-fda4-4dc8-a979-03495753cdd5": 899,
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
}
with patch(
"dspace_statistics_api.app.get_views", return_value=get_views_return_value
):
with patch(
"dspace_statistics_api.app.get_downloads",
return_value=get_downloads_return_value,
):
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 100
assert response.json["currentPage"] == 0
assert isinstance(response.json["totalPages"], int)
assert len(response.json["statistics"]) == 2
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
assert isinstance(response.json["statistics"][1]["views"], int)
assert isinstance(response.json["statistics"][1]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_invalid_dateFrom(client):
"""Test POSTing a request to /collections with an invalid dateFrom parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"dateFrom": "2020-01-01T00:00:00",
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 400
@pytest.mark.xfail
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_dateTo(client):
"""Test POSTing a request to /collections with a valid dateTo parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"dateTo": "2020-01-01T00:00:00Z",
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 100
assert response.json["currentPage"] == 0
assert isinstance(response.json["totalPages"], int)
assert len(response.json["statistics"]) == 2
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
assert isinstance(response.json["statistics"][1]["views"], int)
assert isinstance(response.json["statistics"][1]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_dateTo_mocked(client):
"""Mock test POSTing a request to /collections with a valid dateTo parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"dateTo": "2020-01-01T00:00:00Z",
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
get_views_return_value = {
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 21,
"260548c8-fda4-4dc8-a979-03495753cdd5": 0,
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
}
get_downloads_return_value = {
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 575,
"260548c8-fda4-4dc8-a979-03495753cdd5": 899,
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
}
with patch(
"dspace_statistics_api.app.get_views", return_value=get_views_return_value
):
with patch(
"dspace_statistics_api.app.get_downloads",
return_value=get_downloads_return_value,
):
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 100
assert response.json["currentPage"] == 0
assert isinstance(response.json["totalPages"], int)
assert len(response.json["statistics"]) == 2
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
assert isinstance(response.json["statistics"][1]["views"], int)
assert isinstance(response.json["statistics"][1]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_invalid_dateTo(client):
"""Test POSTing a request to /collections with an invalid dateTo parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"dateFrom": "2020-01-01T00:00:00",
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 400
@pytest.mark.xfail
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_limit(client):
"""Test POSTing a request to /collections with a valid limit parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"limit": 1,
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 1
assert response.json["currentPage"] == 0
assert isinstance(response.json["totalPages"], int)
assert len(response.json["statistics"]) == 1
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_limit_mocked(client):
"""Mock test POSTing a request to /collections with a valid limit parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"limit": 1,
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
get_views_return_value = {"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 21}
get_downloads_return_value = {"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 575}
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
with patch(
"dspace_statistics_api.app.get_views", return_value=get_views_return_value
):
with patch(
"dspace_statistics_api.app.get_downloads",
return_value=get_downloads_return_value,
):
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 1
assert response.json["currentPage"] == 0
assert isinstance(response.json["totalPages"], int)
assert len(response.json["statistics"]) == 1
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_invalid_limit(client):
"""Test POSTing a request to /collections with an invalid limit parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"limit": -1,
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 400
@pytest.mark.xfail
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_page(client):
"""Test POSTing a request to /collections with a valid page parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"page": 0,
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 100
assert response.json["currentPage"] == 0
tests: Fix totalPages A few months ago I fixed the totalPages display to show 1 when we only have one page of results (the page itself is still 0), but I didn't update the tests. See: 4f8cd1097bd0b1384540518304cbfdb88f73d151
2021-04-06 07:54:09 +02:00
assert response.json["totalPages"] == 1
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert len(response.json["statistics"]) == 2
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
assert isinstance(response.json["statistics"][1]["views"], int)
assert isinstance(response.json["statistics"][1]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_valid_page_mocked(client):
"""Mock test POSTing a request to /collections with a valid page parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"page": 0,
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
get_views_return_value = {
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 21,
"260548c8-fda4-4dc8-a979-03495753cdd5": 0,
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
}
get_downloads_return_value = {
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7": 575,
"260548c8-fda4-4dc8-a979-03495753cdd5": 899,
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
}
with patch(
"dspace_statistics_api.app.get_views", return_value=get_views_return_value
):
with patch(
"dspace_statistics_api.app.get_downloads",
return_value=get_downloads_return_value,
):
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 200
assert response.json["limit"] == 100
assert response.json["currentPage"] == 0
assert isinstance(response.json["totalPages"], int)
assert len(response.json["statistics"]) == 2
assert isinstance(response.json["statistics"][0]["views"], int)
assert isinstance(response.json["statistics"][0]["downloads"], int)
assert isinstance(response.json["statistics"][1]["views"], int)
assert isinstance(response.json["statistics"][1]["downloads"], int)
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
def test_post_collections_invalid_page(client):
"""Test POSTing a request to /collections with an invalid page parameter in the request body."""
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
request_body = {
"page": -1,
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
"collections": [
"8ea4b611-1f59-4d4e-b78d-a9921a72cfe7",
"260548c8-fda4-4dc8-a979-03495753cdd5",
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
],
}
tests: Add tests for communities and collections Also, separate tests for items, communities, and collections into their own files, leaving a single test for docs in its own file.
2020-12-20 21:12:13 +01:00
response = client.simulate_post("/collections", json=request_body)
tests/test_api.py: Add tests for /items POST handlers This adds tests for the new /items POST handler, both with mocked data and a live connection to a Solr statistics core. Tests that only work when Solr is available are marked with XFAIL so that they don't turn the whole test suite red. In each test I try to assert as many parameters as we can know for each response so that we cover all expectations. For example, when we test a valid limit parameter we should test whether the response not only has the same limit parameter, but that the number of items has actually been limited and the number of pages has been adjusted accordingly. See: https://docs.pytest.org/en/stable/skipping.html
2020-10-06 15:26:44 +02:00
assert response.status_code == 400
Add vim modeline to all tests
2020-12-24 12:11:12 +01:00
Add whitespace before vim modeline black wants this...
2020-12-24 12:12:06 +01:00
Add vim modeline to all tests
2020-12-24 12:11:12 +01:00
# vim: set sw=4 ts=4 expandtab:
Copy Permalink