alanorth/dspace-statistics-api
1
0
Fork 0
mirror of https://github.com/ilri/dspace-statistics-api.git synced 2024-11-04 22:13:01 +01:00
Code Releases Activity
3e271c7852
dspace-statistics-api/tests/test_api_communities.py

374 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
from falcon import testing
import json
import pytest
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
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_community(client):
"""Test requesting a single community."""
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("/community/bde7139c-d321-46bb-aef6-ae70799e5edb")
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_community(client):
"""Test requesting a single non-existing community."""
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("/item/dec6bfc6-efeb-4f74-8436-79fa80bb5c21")
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_communities(client):
"""Test requesting 100 communities."""
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("/communities", 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_communities_invalid_limit(client):
"""Test requesting 100 communities 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("/communities", 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_communities_invalid_page(client):
"""Test requesting 100 communities 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("/communities", 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_communities_valid_dateFrom(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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_communities_valid_dateFrom_mocked(client):
"""Mock test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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
"bde7139c-d321-46bb-aef6-ae70799e5edb": 309,
"2a920a61-b08a-4642-8e5d-2639c6702b1f": 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
"bde7139c-d321-46bb-aef6-ae70799e5edb": 400,
"2a920a61-b08a-4642-8e5d-2639c6702b1f": 290,
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("/communities", 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_communities_invalid_dateFrom(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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_communities_valid_dateTo(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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_communities_valid_dateTo_mocked(client):
"""Mock test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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
"bde7139c-d321-46bb-aef6-ae70799e5edb": 21,
"2a920a61-b08a-4642-8e5d-2639c6702b1f": 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
"bde7139c-d321-46bb-aef6-ae70799e5edb": 575,
"2a920a61-b08a-4642-8e5d-2639c6702b1f": 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("/communities", 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_communities_invalid_dateTo(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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_communities_valid_limit(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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_communities_valid_limit_mocked(client):
"""Mock test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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 = {"bde7139c-d321-46bb-aef6-ae70799e5edb": 200}
get_downloads_return_value = {"bde7139c-d321-46bb-aef6-ae70799e5edb": 309}
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("/communities", 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_communities_invalid_limit(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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_communities_valid_page(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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_communities_valid_page_mocked(client):
"""Mock test POSTing a request to communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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
"bde7139c-d321-46bb-aef6-ae70799e5edb": 21,
"2a920a61-b08a-4642-8e5d-2639c6702b1f": 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
"bde7139c-d321-46bb-aef6-ae70799e5edb": 575,
"2a920a61-b08a-4642-8e5d-2639c6702b1f": 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("/communities", 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_communities_invalid_page(client):
"""Test POSTing a request to /communities 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
"communities": [
"bde7139c-d321-46bb-aef6-ae70799e5edb",
"2a920a61-b08a-4642-8e5d-2639c6702b1f",
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("/communities", 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
Copy Permalink