import json from unittest.mock import Mock, MagicMock, patch from django.test import TestCase from fetcher import cache class CacheTest(TestCase): @staticmethod def mock_redis(mock_connection): mock_redis = Mock() mock_connection.return_value = Mock(__enter__=Mock(return_value=mock_redis), __exit__=Mock(return_value=False)) return mock_redis @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_input_not_exists(self, mock_connection, mock_jobs): """Testear get artist con un mbid no existente""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) response = cache.get_artist('mbid') self.assertIsNone(response) mock_redis.get.assert_called_with('artist:mbid') mock_jobs.load_artist_on_cache.delay.assert_called_once_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_input_exists(self, mock_connection, mock_jobs): """Testear get artist con un mbid existente""" payload = {'id': 'mbid', 'name': 'name'} mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=json.dumps(payload)) response = cache.get_artist('mbid') self.assertEquals(payload, response) mock_redis.get.assert_called_with('artist:mbid') mock_jobs.load_artist_on_cache.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_disc_input_not_exists(self, mock_connection, mock_jobs): """Testear get disc con un mbid no existente""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) response = cache.get_disc('mbid') self.assertIsNone(response) mock_redis.get.assert_called_with('release_group:mbid') mock_jobs.load_artist_on_cache.delay.asert_called_once_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_disc_input_exists(self, mock_connection, mock_jobs): """Testear get disc con un mbid existente""" payload = {'id': 'mbid', 'title': 'oh no'} mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=json.dumps(payload)) response = cache.get_disc('mbid') self.assertEquals(payload, response) mock_redis.get.assert_called_with('release_group:mbid') mock_jobs.load_artist_on_cache.delay.asert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_discs_of_artists_no_contains(self, mock_connection, mock_jobs): """Testear get discs of artists con mbid que no esta en redis""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=False) result, count = cache.get_discs_of_artist('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(count, 0) mock_redis.__contains__.assert_called_with('artist:mbid:release_groups') mock_jobs.load_artist_on_cache.delay.asert_called_once_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_discs_of_artists_bad_count(self, mock_connection, mock_jobs): """Testear get discs of artists cuando el total no coincide con los almacenados""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=True) mock_redis.get = Mock(return_value=10) mock_redis.zcard = Mock(return_value=0) result, count = cache.get_discs_of_artist('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(count, 0) mock_redis.__contains__.assert_called_with('artist:mbid:release_groups') mock_redis.get.assert_called_with('artist:mbid:release_groups:count') mock_redis.zcard.assert_called_with('artist:mbid:release_groups') mock_jobs.load_artist_on_cache.delay.asert_called_once_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_discs_of_artists_not_all_exists(self, mock_connection, mock_jobs): """Testear get discs of artists cuando no estan guardados todos los discos""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=True) mock_redis.get = Mock(return_value=10) mock_redis.zcard = Mock(return_value=10) mock_redis.zrange = Mock(return_value=range(10)) mock_redis.exists = Mock(return_value=5) result, count = cache.get_discs_of_artist('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(count, 0) mock_redis.__contains__.assert_called_with('artist:mbid:release_groups') mock_redis.get.assert_called_with('artist:mbid:release_groups:count') mock_redis.zcard.assert_called_with('artist:mbid:release_groups') mock_redis.zrange.assert_called_with('artist:mbid:release_groups', 0, 9) mock_redis.exists.assert_called_with(*[f'release_group:{i}' for i in range(10)]) mock_jobs.load_artist_on_cache.delay.asert_called_once_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_discs_of_artists_exists(self, mock_connection, mock_jobs): """Testear get discs of artists cuando todo va bien""" payload = [{'id': i} for i in range(10)] mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=True) mock_redis.get = Mock(return_value=10) mock_redis.zcard = Mock(return_value=10) mock_redis.zrange = Mock(return_value=range(10)) mock_redis.exists = Mock(return_value=10) mock_redis.mget = Mock(return_value=MagicMock()) mock_redis.mget.return_value.__iter__.return_value = [json.dumps(item) for item in payload] result, count = cache.get_discs_of_artist('mbid', 10, 0) self.assertEquals(result, payload) self.assertEquals(count, 10) mock_redis.__contains__.assert_called_with('artist:mbid:release_groups') mock_redis.get.assert_called_with('artist:mbid:release_groups:count') mock_redis.zcard.assert_called_with('artist:mbid:release_groups') mock_redis.zrange.assert_called_with('artist:mbid:release_groups', 0, 9) mock_redis.exists.assert_called_with(*[f'release_group:{i}' for i in range(10)]) mock_jobs.load_artist_on_cache.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_disc_input_not_exists(self, mock_connection, mock_jobs): """Testear get artist of disc cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) result = cache.get_artist_of_disc('mbid') self.assertEquals(result, None) mock_redis.get.assert_called_with('release_group:mbid:artist') mock_jobs.load_entities_of_release_group.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_disc_input_exists(self, mock_connection, mock_jobs): """Testear get artist of disc cuando existe""" payload = {'id': 'artist_id', 'title': 'ohno'} mock_redis = CacheTest.mock_redis(mock_connection) def get(key): if key == 'release_group:mbid:artist': return payload.get('id') elif key == 'artist:artist_id': return json.dumps(payload) else: self.fail('Key inesperada') mock_redis.get = get result = cache.get_artist_of_disc('mbid') self.assertEquals(result, payload) mock_jobs.load_entities_of_release_group.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_release_input_not_exists(self, mock_connection, mock_jobs): """Testear get release cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) result = cache.get_release('mbid') self.assertEquals(result, None) mock_redis.get.assert_called_with('release:mbid') mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_release_input_exists(self, mock_connection, mock_jobs): """Testear get release cuando existe""" payload = {'id': 'release_id', 'title': 'ohno'} mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=json.dumps(payload)) result = cache.get_release('mbid') self.assertEquals(result, payload) mock_redis.get.assert_called_with('release:mbid') mock_jobs.load_entities_of_release.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_discs_not_exists(self, mock_connection, mock_jobs): """Testear get releases of discs cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=False) result, total = cache.get_releases_of_disc('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(total, 0) mock_redis.__contains__.assert_called_with('release_group:mbid:releases') mock_jobs.load_entities_of_release_group.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_discs_not_all_keys(self, mock_connection, mock_jobs): """Testear get releases of discs cuando no estan todas las keys""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=True) mock_redis.get = Mock(return_value=10) mock_redis.zcard = Mock(return_value=5) result, total = cache.get_releases_of_disc('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(total, 0) mock_redis.__contains__.assert_called_with('release_group:mbid:releases') mock_redis.get.assert_called_with('release_group:mbid:releases:count') mock_redis.zcard.assert_called_with('release_group:mbid:releases') mock_jobs.load_entities_of_release_group.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_discs_not_all_keys_loaded(self, mock_connection, mock_jobs): """Testear get releases of discs cuando no estan todas las keys cargadas""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=True) mock_redis.get = Mock(return_value=10) mock_redis.zcard = Mock(return_value=10) mock_redis.zrange = Mock(return_value=range(10)) mock_redis.exists = Mock(return_value=5) result, total = cache.get_releases_of_disc('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(total, 0) mock_redis.__contains__.assert_called_with('release_group:mbid:releases') mock_redis.get.assert_called_with('release_group:mbid:releases:count') mock_redis.zcard.assert_called_with('release_group:mbid:releases') mock_redis.zrange.assert_called_with('release_group:mbid:releases', 0, 9) mock_redis.exists.assert_called_with(*[f'release:{id}' for id in range(10)]) mock_jobs.load_entities_of_release_group.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_discs_all_god(self, mock_connection, mock_jobs): """Testear get releases of discs cuando existe todo""" payload = [{'id': i} for i in range(10)] mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.__contains__ = Mock(return_value=True) mock_redis.get = Mock(return_value=10) mock_redis.zcard = Mock(return_value=10) mock_redis.zrange = Mock(return_value=range(10)) mock_redis.exists = Mock(return_value=10) mock_redis.mget = Mock(return_value=MagicMock()) mock_redis.mget.return_value.__iter__.return_value = [json.dumps(item) for item in payload] result, total = cache.get_releases_of_disc('mbid', 10, 0) self.assertEquals(result, payload) self.assertEquals(total, 10) mock_redis.__contains__.assert_called_with('release_group:mbid:releases') mock_redis.get.assert_called_with('release_group:mbid:releases:count') mock_redis.zcard.assert_called_with('release_group:mbid:releases') mock_redis.zrange.assert_called_with('release_group:mbid:releases', 0, 9) mock_redis.exists.assert_called_with(*[f'release:{id}' for id in range(10)]) mock_jobs.load_entities_of_release_group.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_release_input_no_exists(self, mock_connection, mock_jobs): """Testear get artist of release cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) result = cache.get_artist_of_release('mbid') self.assertEquals(result, None) mock_redis.get.assert_called_with('release:mbid:artist') mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_release_input_not_saved(self, mock_connection, mock_jobs): """Testear get artist of release cuando existe el id por aun no es guardado""" mock_redis = CacheTest.mock_redis(mock_connection) def get(key): if key == 'release:mbid:artist': return 'artist_id' if key == 'artist:artist_id': return None else: self.fail('Key inesperada') mock_redis.get = get result = cache.get_artist_of_release('mbid') self.assertEquals(result, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_release_exists(self, mock_connection, mock_jobs): """Testear get artist of release cuando existe""" payload = {'id': 'artist_id', 'name': 'ohno'} mock_redis = CacheTest.mock_redis(mock_connection) def get(key): if key == 'release:mbid:artist': return 'artist_id' if key == 'artist:artist_id': return json.dumps(payload) else: self.fail('Key inesperada') mock_redis.get = get result = cache.get_artist_of_release('mbid') self.assertEquals(result, payload) mock_jobs.load_entities_of_release.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recording_not_exists(self, mock_connection, mock_jobs): """Testear get recording cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) response = cache.get_recording('mbid') self.assertEquals(response, None) mock_redis.get.assert_called_with('recording:mbid') mock_jobs.load_entities_of_recording.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recording_exists(self, mock_connection, mock_jobs): """Testear get recording cuando existe""" payload = {'id': 'mbid', 'title': 'ohno'} mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=json.dumps(payload)) response = cache.get_recording('mbid') self.assertEquals(response, payload) mock_redis.get.assert_called_with('recording:mbid') mock_jobs.load_entities_of_recording.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recordings_of_release_no_medias(self, mock_connection, mock_jobs): """Testear get recordings of release cuando no hay ninguna media asociada a la release""" mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(self, key): if key == 'release:mbid:media': return False else: self.fail('Key inesperada en __contains__') mock_redis.__contains__ = __contains__ response = cache.get_recordings_of_release('mbid') self.assertEquals(response, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recordings_of_release_not_all_medias(self, mock_connection, mock_jobs): """Testear get recordings of release cuando no estan todos los ids de medias que deberian""" mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'release:mbid:media': return True else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'release:mbid:media:count': return 2 else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'release:mbid:media': return 1 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard response = cache.get_recordings_of_release('mbid') self.assertEquals(response, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recordings_of_release_all_medias_no_recordings(self, mock_connection, mock_jobs): """Testear get recordings of release estan las medias pero ninguna tiene recordings""" medias = [{'id': id, 'position': id} for id in range(1, 3)] mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'release:mbid:media': return True elif key == 'release:mbid:media:1:recordings': return False elif key == 'release:mbid:media:2:recordings': return False else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'release:mbid:media:count': return 2 else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'release:mbid:media': return 2 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard def zrange(key, start, finish): if key == 'release:mbid:media': return [json.dumps(media) for media in medias] else: self.fail(f'Key inesperada en zrange: {key}') mock_redis.zrange = zrange response = cache.get_recordings_of_release('mbid') self.assertEquals(response, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recordings_of_release_all_medias_no_recordings_count(self, mock_connection, mock_jobs): """Testear get recordings of release estan las medias y hay una lista de recordings pero no se tiene la cuenta de ellas""" medias = [{'id': id, 'position': id} for id in range(1, 3)] mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'release:mbid:media': return True elif key == 'release:mbid:media:1:recordings': return True elif key == 'release:mbid:media:2:recordings': return True elif key == 'release:mbid:media:1:recordings:count': return False elif key == 'release:mbid:media:2:recordings:count': return False else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'release:mbid:media:count': return 2 elif key == 'release:mbid:media:1:recordings:count': return None elif key == 'release:mbid:media:2:recordings:count': return None else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'release:mbid:media': return 2 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard def zrange(key, start, finish): if key == 'release:mbid:media': return [json.dumps(media) for media in medias] else: self.fail(f'Key inesperada en zrange: {key}') mock_redis.zrange = zrange response = cache.get_recordings_of_release('mbid') self.assertEquals(response, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recordings_of_release_all_medias_bad_recording_count(self, mock_connection, mock_jobs): """Testear get recordings of release con las medias pero el conteo de grabaciones de la primera, no coincide con el total""" medias = [{'id': id, 'position': id} for id in range(1, 3)] mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'release:mbid:media': return True elif key == 'release:mbid:media:1:recordings': return True elif key == 'release:mbid:media:2:recordings': return True elif key == 'release:mbid:media:1:recordings:count': return True elif key == 'release:mbid:media:2:recordings:count': return True else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'release:mbid:media:count': return 2 if key == 'release:mbid:media:1:recordings:count': return 10 if key == 'release:mbid:media:2:recordings:count': return 10 else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'release:mbid:media': return 2 if key == 'release:mbid:media:1:recordings': return 5 if key == 'release:mbid:media:2:recordings': return 5 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard def zrange(key, start, finish): if key == 'release:mbid:media': return [json.dumps(media) for media in medias] else: self.fail(f'Key inesperada en zrange: {key}') mock_redis.zrange = zrange response = cache.get_recordings_of_release('mbid') self.assertEquals(response, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recordings_of_release_all_medias_no_exists_recording(self, mock_connection, mock_jobs): """Testear get recordings of release con las medias pero no todos los recordings existen""" medias = [{'id': id, 'position': id} for id in range(1, 3)] mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'release:mbid:media': return True elif key == 'release:mbid:media:1:recordings': return True elif key == 'release:mbid:media:2:recordings': return True elif key == 'release:mbid:media:1:recordings:count': return True elif key == 'release:mbid:media:2:recordings:count': return True else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'release:mbid:media:count': return 2 if key == 'release:mbid:media:1:recordings:count': return 10 if key == 'release:mbid:media:2:recordings:count': return 10 else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'release:mbid:media': return 2 if key == 'release:mbid:media:1:recordings': return 10 if key == 'release:mbid:media:2:recordings': return 10 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard def zrange(key, start, finish): if key == 'release:mbid:media': return [json.dumps(media) for media in medias] elif key == 'release:mbid:media:1:recordings': return range(1, 11) elif key == 'release:mbid:media:2:recordings': return range(1, 11) else: self.fail(f'Key inesperada en zrange: {key}') mock_redis.zrange = zrange mock_redis.exists = Mock(return_value=8) response = cache.get_recordings_of_release('mbid') self.assertEquals(response, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_recordings_of_release_all_good(self, mock_connection, mock_jobs): """Testear get recordings of release cuando esta todo como se espera""" medias = [{'id': id, 'position': id} for id in range(1, 3)] mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'release:mbid:media': return True elif key == 'release:mbid:media:1:recordings': return True elif key == 'release:mbid:media:2:recordings': return True elif key == 'release:mbid:media:1:recordings:count': return True elif key == 'release:mbid:media:2:recordings:count': return True else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'release:mbid:media:count': return 2 if key == 'release:mbid:media:1:recordings:count': return 10 if key == 'release:mbid:media:2:recordings:count': return 10 if key in [f'recording:{i}' for i in range(1, 11)]: return json.dumps({'id': 'someid', 'title': 'sometitle'}) else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'release:mbid:media': return 2 if key == 'release:mbid:media:1:recordings': return 10 if key == 'release:mbid:media:2:recordings': return 10 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard def zrange(key, start, finish): if key == 'release:mbid:media': return [json.dumps(media) for media in medias] elif key == 'release:mbid:media:1:recordings': return range(1, 11) elif key == 'release:mbid:media:2:recordings': return range(1, 11) else: self.fail(f'Key inesperada en zrange: {key}') mock_redis.zrange = zrange mock_redis.exists = Mock(return_value=10) expected = [{'id': i, 'position': i, 'recordings': [{'id': 'someid', 'title': 'sometitle'} for i in range(10)]} for i in range(1, 3)] response = cache.get_recordings_of_release('mbid') self.assertEquals(response, expected) mock_jobs.load_entities_of_release.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_recording_no_exists(self, mock_connection, mock_jobs): """Testear get releases of recording cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'recording:mbid:release': return False elif key == 'recording:mbid:release:count': return False else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ result, total = cache.get_releases_of_recording('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(total, 0) mock_jobs.load_entities_of_recording.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_recording_not_all(self, mock_connection, mock_jobs): """Testear get releases of recording cuando no coinciden las keys con la cantidad almacenada""" mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'recording:mbid:release': return True elif key == 'recording:mbid:release:count': return True else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'recording:mbid:release:count': return 10 else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'recording:mbid:release': return 5 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard result, total = cache.get_releases_of_recording('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(total, 0) mock_jobs.load_entities_of_recording.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_recording_all_but_no_exists(self, mock_connection, mock_jobs): """Testear get releases of recording cuando estan todas las keys pero no existen todas""" mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'recording:mbid:release': return True elif key == 'recording:mbid:release:count': return True else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'recording:mbid:release:count': return 10 else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'recording:mbid:release': return 10 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard def zrange(key, start, end): if key == 'recording:mbid:release': return range(10) else: self.fail(f'Key inesperada en zrange: {key}') mock_redis.zrange = zrange mock_redis.exists = Mock(return_value=8) result, total = cache.get_releases_of_recording('mbid', 10, 0) self.assertEquals(result, None) self.assertEquals(total, 0) mock_jobs.load_entities_of_recording.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_releases_of_recording_all_good(self, mock_connection, mock_jobs): """Testear get releases of recording cuando esta todo""" mock_redis = CacheTest.mock_redis(mock_connection) def __contains__(_, key): if key == 'recording:mbid:release': return True elif key == 'recording:mbid:release:count': return True else: self.fail(f'Key inesperada en __contains__: {key}') mock_redis.__contains__ = __contains__ def get(key): if key == 'recording:mbid:release:count': return 10 else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get def zcard(key): if key == 'recording:mbid:release': return 10 else: self.fail(f'Key inesperada en zcard: {key}') mock_redis.zcard = zcard def zrange(key, start, end): if key == 'recording:mbid:release': return range(10) else: self.fail(f'Key inesperada en zrange: {key}') mock_redis.zrange = zrange mock_redis.exists = Mock(return_value=10) releases = [{'id': i} for i in range(10)] mock_redis.mget = Mock(return_value=[json.dumps(release) for release in releases]) result, total = cache.get_releases_of_recording('mbid', 10, 0) self.assertEquals(result, releases) self.assertEquals(total, 10) mock_jobs.load_entities_of_recording.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_recordings_input_not_exists(self, mock_connection, mock_jobs): """Testear get artist of recording cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) def get(key): if key == 'recording:mbid:artist': return None else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get result = cache.get_artist_of_recording('mbid') self.assertEquals(result, None) mock_jobs.load_entities_of_recording.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_recordings_not_loaded(self, mock_connection, mock_jobs): """Testear get artist of recording cuando existe id pero no esta cargado""" mock_redis = CacheTest.mock_redis(mock_connection) def get(key): if key == 'recording:mbid:artist': return 'artist_id' elif key == 'artist:artist_id': return None else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get result = cache.get_artist_of_recording('mbid') self.assertEquals(result, None) mock_jobs.load_entities_of_recording.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_artist_of_recordings_exists(self, mock_connection, mock_jobs): """Testear get artist of recording cuando existe""" mock_redis = CacheTest.mock_redis(mock_connection) def get(key): if key == 'recording:mbid:artist': return 'artist_id' elif key == 'artist:artist_id': return json.dumps({'id': 'artist_id'}) else: self.fail(f'Key inesperada en get: {key}') mock_redis.get = get result = cache.get_artist_of_recording('mbid') self.assertEquals(result, {'id': 'artist_id'}) mock_jobs.load_entities_of_recording.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_cover_art_disc_no_exists(self, mock_connection, mock_jobs): """Testear get cover art of disc cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) result = cache.get_cover_art_disc('mbid') self.assertEquals(result, None) mock_jobs.load_entities_of_release_group.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_cover_art_disc_exists(self, mock_connection, mock_jobs): """Testear get cover art of disc cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=json.dumps({'id': 'mbid'})) result = cache.get_cover_art_disc('mbid') self.assertEquals(result, {'id': 'mbid'}) mock_jobs.load_entities_of_release_group.delay.assert_not_called() @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_cover_art_release_no_exists(self, mock_connection, mock_jobs): """Testear get cover art of release cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=None) result = cache.get_cover_art_release('mbid') self.assertEquals(result, None) mock_jobs.load_entities_of_release.delay.assert_called_with('mbid') @patch('fetcher.cache.jobs') @patch('fetcher.cache.get_redis_connection') def test_get_cover_art_release_exists(self, mock_connection, mock_jobs): """Testear get cover art of disc cuando no existe""" mock_redis = CacheTest.mock_redis(mock_connection) mock_redis.get = Mock(return_value=json.dumps({'id': 'mbid'})) result = cache.get_cover_art_release('mbid') self.assertEquals(result, {'id': 'mbid'}) mock_jobs.load_entities_of_release.delay.assert_not_called()