alanorth/dspace-statistics-api
1
0
Fork 0
mirror of https://github.com/ilri/dspace-statistics-api.git synced 2024-11-16 19:37:04 +01:00
Code Releases Activity
acfe87b91a
dspace-statistics-api/tests/test_api_collections.py

378 lines
13 KiB
Python
Raw Normal View History

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
Add initial API tests Test the basic assumptions of the API like response codes and types.
2018-11-11 10:51:22 +01:00
from dspace_statistics_api.app import api
@pytest.fixture
def client():
return testing.TestClient(api)
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
assert response.json["totalPages"] == 0
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