From 32b396207058ba6cb429d2113938bc755f68db73 Mon Sep 17 00:00:00 2001 From: Ansh Goyal Date: Sat, 17 Sep 2022 06:50:38 +0000 Subject: [PATCH] feat: Add Tests for entity endpoints --- critiquebrainz/ws/artist/test/__init__.py | 0 critiquebrainz/ws/artist/test/views_test.py | 89 +++++++++++++++++++ critiquebrainz/ws/bb_author/test/__init__.py | 0 .../ws/bb_author/test/views_test.py | 88 ++++++++++++++++++ .../ws/bb_edition_group/test/__init__.py | 0 .../ws/bb_edition_group/test/views_test.py | 88 ++++++++++++++++++ .../ws/bb_literary_work/test/__init__.py | 0 .../ws/bb_literary_work/test/views_test.py | 89 +++++++++++++++++++ critiquebrainz/ws/bb_series/test/__init__.py | 0 .../ws/bb_series/test/views_test.py | 88 ++++++++++++++++++ critiquebrainz/ws/event/test/__init__.py | 0 critiquebrainz/ws/event/test/views_test.py | 88 ++++++++++++++++++ critiquebrainz/ws/label/test/__init__.py | 0 critiquebrainz/ws/label/test/views_test.py | 88 ++++++++++++++++++ critiquebrainz/ws/place/test/__init__.py | 0 critiquebrainz/ws/place/test/views_test.py | 88 ++++++++++++++++++ critiquebrainz/ws/recording/test/__init__.py | 0 .../ws/recording/test/views_test.py | 88 ++++++++++++++++++ .../ws/release_group/test/__init__.py | 0 .../ws/release_group/test/views_test.py | 88 ++++++++++++++++++ critiquebrainz/ws/work/test/__init__.py | 0 critiquebrainz/ws/work/test/views_test.py | 88 ++++++++++++++++++ 22 files changed, 970 insertions(+) create mode 100644 critiquebrainz/ws/artist/test/__init__.py create mode 100644 critiquebrainz/ws/artist/test/views_test.py create mode 100644 critiquebrainz/ws/bb_author/test/__init__.py create mode 100644 critiquebrainz/ws/bb_author/test/views_test.py create mode 100644 critiquebrainz/ws/bb_edition_group/test/__init__.py create mode 100644 critiquebrainz/ws/bb_edition_group/test/views_test.py create mode 100644 critiquebrainz/ws/bb_literary_work/test/__init__.py create mode 100644 critiquebrainz/ws/bb_literary_work/test/views_test.py create mode 100644 critiquebrainz/ws/bb_series/test/__init__.py create mode 100644 critiquebrainz/ws/bb_series/test/views_test.py create mode 100644 critiquebrainz/ws/event/test/__init__.py create mode 100644 critiquebrainz/ws/event/test/views_test.py create mode 100644 critiquebrainz/ws/label/test/__init__.py create mode 100644 critiquebrainz/ws/label/test/views_test.py create mode 100644 critiquebrainz/ws/place/test/__init__.py create mode 100644 critiquebrainz/ws/place/test/views_test.py create mode 100644 critiquebrainz/ws/recording/test/__init__.py create mode 100644 critiquebrainz/ws/recording/test/views_test.py create mode 100644 critiquebrainz/ws/release_group/test/__init__.py create mode 100644 critiquebrainz/ws/release_group/test/views_test.py create mode 100644 critiquebrainz/ws/work/test/__init__.py create mode 100644 critiquebrainz/ws/work/test/views_test.py diff --git a/critiquebrainz/ws/artist/test/__init__.py b/critiquebrainz/ws/artist/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/artist/test/views_test.py b/critiquebrainz/ws/artist/test/views_test.py new file mode 100644 index 000000000..ba7915891 --- /dev/null +++ b/critiquebrainz/ws/artist/test/views_test.py @@ -0,0 +1,89 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class ArtistViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(ArtistViewsTestCase, self).setUp() + + self.artist_id1 = "f59c5520-5f46-4d2c-b2c4-822eabf53419" + self.artist_id2 = "83d91898-7763-47d7-b03b-b92132375c47" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.artist_id1, + entity_type='artist', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.artist_id2, + entity_type='artist', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_artist_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/artist/f59c5520-5f46-4d2c-b2c4-822eabf53419') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for an artist which does not exist + response = self.client.get('/artist/f59c5520-5f46-4d2c-b2c4-822eabf53417') + self.assert404(response) + + def test_artist_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/artist/f59c5520-5f46-4d2c-b2c4-822eabf53419?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.artist_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/artist/83d91898-7763-47d7-b03b-b92132375c47?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/artist/83d91898-7763-47d7-b03b-b92132375c47?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertTrue(cache_value is not None) + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/bb_author/test/__init__.py b/critiquebrainz/ws/bb_author/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/bb_author/test/views_test.py b/critiquebrainz/ws/bb_author/test/views_test.py new file mode 100644 index 000000000..18e4e9ca5 --- /dev/null +++ b/critiquebrainz/ws/bb_author/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class AuthorViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(AuthorViewsTestCase, self).setUp() + + self.author_id1 = "b8f9bd89-79d1-497e-811f-18576321111c" + self.author_id2 = "b2507eee-1391-47c5-93e6-ca972bd8e0e0" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.author_id1, + entity_type='bb_author', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.author_id2, + entity_type='bb_author', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_author_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/author/b8f9bd89-79d1-497e-811f-18576321111c') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for an author which does not exist + response = self.client.get('/author/b8f9bd89-79d1-497e-811f-18576321111g') + self.assert404(response) + + def test_author_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/author/b8f9bd89-79d1-497e-811f-18576321111c?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.author_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/author/b2507eee-1391-47c5-93e6-ca972bd8e0e0?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/author/b2507eee-1391-47c5-93e6-ca972bd8e0e0?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/bb_edition_group/test/__init__.py b/critiquebrainz/ws/bb_edition_group/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/bb_edition_group/test/views_test.py b/critiquebrainz/ws/bb_edition_group/test/views_test.py new file mode 100644 index 000000000..e66543508 --- /dev/null +++ b/critiquebrainz/ws/bb_edition_group/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class EditionGroupViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(EditionGroupViewsTestCase, self).setUp() + + self.edition_group_id1 = "ac4ae236-6bee-4335-9e04-21314a478f9f" + self.edition_group_id2 = "ab87aa42-3cb7-478c-bba7-09192d04f252" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.edition_group_id1, + entity_type='bb_edition_group', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.edition_group_id2, + entity_type='bb_edition_group', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_edition_group_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/edition-group/ac4ae236-6bee-4335-9e04-21314a478f9f') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for an edition group that doesn't exist + response = self.client.get('/edition-group/ac4ae236-6bee-4335-9e04-21314a478f9d') + self.assert404(response) + + def test_edition_group_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/edition-group/ac4ae236-6bee-4335-9e04-21314a478f9f?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.edition_group_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/edition-group/ab87aa42-3cb7-478c-bba7-09192d04f252?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/edition-group/ab87aa42-3cb7-478c-bba7-09192d04f252?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/bb_literary_work/test/__init__.py b/critiquebrainz/ws/bb_literary_work/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/bb_literary_work/test/views_test.py b/critiquebrainz/ws/bb_literary_work/test/views_test.py new file mode 100644 index 000000000..e21dca5ba --- /dev/null +++ b/critiquebrainz/ws/bb_literary_work/test/views_test.py @@ -0,0 +1,89 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class LiteraryWorkViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(LiteraryWorkViewsTestCase, self).setUp() + + self.literary_work_id1 = "56efa555-abd5-4ccb-89a6-ff9d9021971f" + self.literary_work_id2 = "0e03bc2a-2867-4687-afee-e211ece30772" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.literary_work_id1, + entity_type='bb_literary_work', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.literary_work_id2, + entity_type='bb_literary_work', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_literary_work_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/literary-work/56efa555-abd5-4ccb-89a6-ff9d9021971f') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for a literary work that doesn't exist + response = self.client.get('/literary-work/56efa555-abd5-4ccb-89a6-ff9d9021971g') + self.assert404(response) + + def test_literary_work_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/literary-work/56efa555-abd5-4ccb-89a6-ff9d9021971f?username=%s' % + self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.literary_work_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/literary-work/0e03bc2a-2867-4687-afee-e211ece30772?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/literary-work/0e03bc2a-2867-4687-afee-e211ece30772?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/bb_series/test/__init__.py b/critiquebrainz/ws/bb_series/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/bb_series/test/views_test.py b/critiquebrainz/ws/bb_series/test/views_test.py new file mode 100644 index 000000000..e43c0d0c7 --- /dev/null +++ b/critiquebrainz/ws/bb_series/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class seriesViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(seriesViewsTestCase, self).setUp() + + self.series_id1 = "968ef651-6a70-410f-9b17-f326ee0062c3" + self.series_id2 = "29b7d60f-0be1-428d-8a2d-71f3abb8d218" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.series_id1, + entity_type='bb_series', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.series_id2, + entity_type='bb_series', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_series_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/series/968ef651-6a70-410f-9b17-f326ee0062c3') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for a series which does not exist + response = self.client.get('/series/968ef651-6a70-410f-9b17-f326ee0062c1') + self.assert404(response) + + def test_series_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/series/968ef651-6a70-410f-9b17-f326ee0062c3?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.series_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/series/29b7d60f-0be1-428d-8a2d-71f3abb8d218?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/series/29b7d60f-0be1-428d-8a2d-71f3abb8d218?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/event/test/__init__.py b/critiquebrainz/ws/event/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/event/test/views_test.py b/critiquebrainz/ws/event/test/views_test.py new file mode 100644 index 000000000..a552788ef --- /dev/null +++ b/critiquebrainz/ws/event/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class EventViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(EventViewsTestCase, self).setUp() + + self.event_id1 = "fe39727a-3d21-4066-9345-3970cbd6cca4" + self.event_id2 = "7f2d3cd9-c2e1-4adc-841f-dab3de070a75" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.event_id1, + entity_type='event', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.event_id2, + entity_type='event', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_event_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/event/fe39727a-3d21-4066-9345-3970cbd6cca4') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for an event that doesn't exist + response = self.client.get('/event/fe39727a-3d21-4066-9345-3970cbd6cca1') + self.assert404(response) + + def test_event_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/event/fe39727a-3d21-4066-9345-3970cbd6cca4?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.event_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/event/7f2d3cd9-c2e1-4adc-841f-dab3de070a75?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/event/7f2d3cd9-c2e1-4adc-841f-dab3de070a75?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/label/test/__init__.py b/critiquebrainz/ws/label/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/label/test/views_test.py b/critiquebrainz/ws/label/test/views_test.py new file mode 100644 index 000000000..300dc6820 --- /dev/null +++ b/critiquebrainz/ws/label/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class LabelViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(LabelViewsTestCase, self).setUp() + + self.label_id1 = "13a464dc-b9fd-4d16-a4f4-d4316f6a46c7" + self.label_id2 = "d8067fa7-8758-4527-b436-ce5faff3e576" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.label_id1, + entity_type='label', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.label_id2, + entity_type='label', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_label_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/label/13a464dc-b9fd-4d16-a4f4-d4316f6a46c7') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for a label that doesn't exist + response = self.client.get('/label/13a464dc-b9fd-4d16-a4f4-d4316f6a46c1') + self.assert404(response) + + def test_label_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/label/13a464dc-b9fd-4d16-a4f4-d4316f6a46c7?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.label_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/label/d8067fa7-8758-4527-b436-ce5faff3e576?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/label/d8067fa7-8758-4527-b436-ce5faff3e576?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/place/test/__init__.py b/critiquebrainz/ws/place/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/place/test/views_test.py b/critiquebrainz/ws/place/test/views_test.py new file mode 100644 index 000000000..ab0b2e07e --- /dev/null +++ b/critiquebrainz/ws/place/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class PlaceViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(PlaceViewsTestCase, self).setUp() + + self.place_id1 = "4352063b-a833-421b-a420-e7fb295dece0" + self.place_id2 = "853b36f9-8806-459c-9480-0766b8f9354b" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.place_id1, + entity_type='place', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.place_id2, + entity_type='place', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_place_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/place/4352063b-a833-421b-a420-e7fb295dece0') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for a place that doesn't exist + response = self.client.get('/place/4352063b-a833-421b-a420-e7fb295dece9') + self.assert404(response) + + def test_place_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/place/4352063b-a833-421b-a420-e7fb295dece0?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.place_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/place/853b36f9-8806-459c-9480-0766b8f9354b?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/place/853b36f9-8806-459c-9480-0766b8f9354b?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/recording/test/__init__.py b/critiquebrainz/ws/recording/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/recording/test/views_test.py b/critiquebrainz/ws/recording/test/views_test.py new file mode 100644 index 000000000..2dfa755e5 --- /dev/null +++ b/critiquebrainz/ws/recording/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class RecordingViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(RecordingViewsTestCase, self).setUp() + + self.recording_id1 = "442ddce2-ffa1-4865-81d2-b42c40fec7c5" + self.recording_id2 = "7a03530e-1018-458c-a254-b814a4b62b72" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.recording_id1, + entity_type='recording', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.recording_id2, + entity_type='recording', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_recording_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/recording/442ddce2-ffa1-4865-81d2-b42c40fec7c5') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for a recording that doesn't exist + response = self.client.get('/recording/442ddce2-ffa1-4865-81d2-b42c40fec7c1') + self.assert404(response) + + def test_recording_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/recording/442ddce2-ffa1-4865-81d2-b42c40fec7c5?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.recording_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/recording/7a03530e-1018-458c-a254-b814a4b62b72?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/recording/7a03530e-1018-458c-a254-b814a4b62b72?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/release_group/test/__init__.py b/critiquebrainz/ws/release_group/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/release_group/test/views_test.py b/critiquebrainz/ws/release_group/test/views_test.py new file mode 100644 index 000000000..9db56b291 --- /dev/null +++ b/critiquebrainz/ws/release_group/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class ReleaseGroupViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(ReleaseGroupViewsTestCase, self).setUp() + + self.release_group_id1 = "1eff4a06-056e-4dc7-91c4-0cbc5878f3c3" + self.release_group_id2 = "c033d28b-fe43-3744-a5f8-50b30a100dcb" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.release_group_id1, + entity_type='release_group', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.release_group_id2, + entity_type='release_group', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_release_group_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/release-group/1eff4a06-056e-4dc7-91c4-0cbc5878f3c3') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for a release_group that doesn't exist + response = self.client.get('/release-group/1eff4a06-056e-4dc7-91c4-0cbc5878f3c1') + self.assert404(response) + + def test_release_group_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/release-group/1eff4a06-056e-4dc7-91c4-0cbc5878f3c3?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.release_group_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/release-group/c033d28b-fe43-3744-a5f8-50b30a100dcb?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/release-group/c033d28b-fe43-3744-a5f8-50b30a100dcb?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text']) diff --git a/critiquebrainz/ws/work/test/__init__.py b/critiquebrainz/ws/work/test/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/critiquebrainz/ws/work/test/views_test.py b/critiquebrainz/ws/work/test/views_test.py new file mode 100644 index 000000000..ac45fdfdc --- /dev/null +++ b/critiquebrainz/ws/work/test/views_test.py @@ -0,0 +1,88 @@ +from brainzutils import cache + +import critiquebrainz.db.license as db_license +import critiquebrainz.db.review as db_review +import critiquebrainz.db.users as db_users +from critiquebrainz.db.user import User +from critiquebrainz.ws.testing import WebServiceTestCase + + +class WorkViewsTestCase(WebServiceTestCase): + + def setUp(self): + super(WorkViewsTestCase, self).setUp() + + self.work_id1 = "0e5a48f3-7d21-365c-bfb7-98d9865ea1dd" + self.work_id2 = "fd881e93-c199-4c86-81a7-cabc044948d0" + + self.user = User(db_users.get_or_create(1, "Tester", new_user_data={ + "display_name": "test user", + })) + self.another_user = User(db_users.get_or_create(2, "Hacker!", new_user_data={ + "display_name": "test hacker", + })) + self.license = db_license.create( + id="CC BY-SA 3.0", + full_name="Created so we can fill the form correctly.", + ) + self.review = dict( + entity_id=self.work_id1, + entity_type='work', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + self.review2 = dict( + entity_id=self.work_id2, + entity_type='work', + user_id=self.user.id, + text="Testing! This text should be on the page.", + rating=5, + is_draft=False, + license_id=self.license["id"], + ) + + def create_dummy_review(self): + return db_review.create(**self.review) + + def create_dummy_review2(self): + return db_review.create(**self.review2) + + def test_work_endpoint(self): + review = self.create_dummy_review() + response = self.client.get('/work/0e5a48f3-7d21-365c-bfb7-98d9865ea1dd') + + self.assert200(response) + self.assertIn(review['text'], response.json['top_reviews'][0]['text']) + + self.assertEqual(5, response.json['average_rating']) + self.assertEqual(1, response.json['reviews_count']) + + # Test for a work that doesn't exist + response = self.client.get('/work/0e5a48f3-7d21-365c-bfb7-98d9865ea1d1') + self.assert404(response) + + def test_work_user_reviews(self): + review = self.create_dummy_review() + response = self.client.get('/work/0e5a48f3-7d21-365c-bfb7-98d9865ea1dd?username=%s' % self.user.musicbrainz_username) + + self.assert200(response) + self.assertIn(review['text'], response.json['user_review']['text']) + + def test_user_cache_tracking(self): + track_key = cache.gen_key("entity_api", self.work_id2, self.user.musicbrainz_username, "user_review") + + # Make sure the cache is empty + self.client.get('/work/fd881e93-c199-4c86-81a7-cabc044948d0?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + self.assertEqual([], cache_value) + + review = self.create_dummy_review2() + + # Check if the cache is populated after the request + self.client.get('/work/fd881e93-c199-4c86-81a7-cabc044948d0?username=%s' % self.user.musicbrainz_username) + cache_value = cache.get(track_key, namespace="Review") + + self.assertIn(review['text'], cache_value['text'])