Testeo de get_recordings of release

fetcher/cache.py

@@ -165,7 +165,7 @@ def get_recordings_of_release(mbid):
 
         media_count = int(redis.get(f'{medias_key}:count'))
         if redis.zcard(medias_key) != media_count:
-            _log.debug('La cantidad de medias de la release no coinciden con el total', mbid)
+            _log.debug('La cantidad de medias de la release %s no coinciden con el total', mbid)
             jobs.load_entities_of_release.delay(mbid)
             return None
 
@@ -179,7 +179,8 @@ def get_recordings_of_release(mbid):
 
             recordings_count = int(redis.get(f'{recordings_key}:count'))
             if redis.zcard(recordings_key) != recordings_count:
-                _log.debug('La cantidad de recordings de la media no coinciden con el total', mbid)
+                _log.debug('La cantidad de recordings de la media %s no coinciden con el total',
+                           mbid)
                 jobs.load_entities_of_release.delay(mbid)
                 return None
 

fetcher/test.py

@@ -1,11 +1,10 @@
 import json
-import logging
-from unittest.mock import Mock, MagicMock, patch
-from django.test import TestCase
-from fetcher import cache
 
-# Parece que es molesto el logging en el output del test
+from unittest.mock import Mock, MagicMock, patch
-logging.disable()
+
+from django.test import TestCase
+
+from fetcher import cache
 
 
 class CacheTest(TestCase):
@@ -388,3 +387,281 @@ class CacheTest(TestCase):
 
         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_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
+            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
+            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
+            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()