mygpo/maintenance/tests.py

   1 #
   2 # This file is part of my.gpodder.org.
   3 #
   4 # my.gpodder.org is free software: you can redistribute it and/or modify it
   5 # under the terms of the GNU Affero General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or (at your
   7 # option) any later version.
   8 #
   9 # my.gpodder.org is distributed in the hope that it will be useful, but
  10 # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11 # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
  12 # License for more details.
  13 #
  14 # You should have received a copy of the GNU Affero General Public License
  15 # along with my.gpodder.org. If not, see <http://www.gnu.org/licenses/>.
  16 #
  17
  18 import uuid
  19 from datetime import datetime
  20 import unittest
  21 from collections import Counter
  22
  23 from django.test import TestCase, TransactionTestCase
  24 from django.test.utils import override_settings
  25 from django.contrib.auth import get_user_model
  26
  27 from mygpo.podcasts.models import Podcast, Episode
  28 from mygpo.history.models import EpisodeHistoryEntry
  29 from mygpo.maintenance.merge import PodcastMerger
  30
  31
  32 def u():
  33     return uuid.uuid1()
  34
  35
  36 class SimpleMergeTests(TestCase):
  37
  38     def setUp(self):
  39         self.podcast1 = Podcast.objects.get_or_create_for_url(
  40             'http://example.com/simple-merge-test-feed.rss',
  41             defaults={'title': 'Podcast 1'},
  42         )
  43         self.podcast2 = Podcast.objects.get_or_create_for_url(
  44             'http://simple-merge-test.org/podcast/',
  45             defaults={'title': 'Podcast 2'},
  46         )
  47
  48         self.episode1 = Episode.objects.get_or_create_for_url(
  49             self.podcast1, 'http://example.com/simple-merge-test-episode1.mp3',
  50             defaults={
  51                 'title': 'Episode 1 A',
  52             })
  53         self.episode2 = Episode.objects.get_or_create_for_url(
  54             self.podcast2, 'http://example.com/simple-merge-test-episode1.mp3',
  55             defaults={
  56                 'title': 'Episode 1 B',
  57             })
  58
  59     def test_merge_podcasts(self):
  60         # decide which episodes to merge
  61         groups = [(0, [self.episode1, self.episode2])]
  62         counter = Counter()
  63         pm = PodcastMerger([self.podcast1, self.podcast2], counter, groups)
  64         pm.merge()
  65
  66
  67 @override_settings(CACHE={})
  68 class MergeTests(TransactionTestCase):
  69     """ Tests merging of two podcasts, their episodes and states """
  70
  71     def setUp(self):
  72         self.podcast1 = Podcast.objects.get_or_create_for_url(
  73             'http://example.com/merge-test-feed.rss',
  74             defaults={'title': 'Podcast 1'},
  75         )
  76         self.podcast2 = Podcast.objects.get_or_create_for_url(
  77             'http://merge-test.org/podcast/',
  78             defaults={'title': 'Podcast 2'},
  79         )
  80
  81         self.episode1 = Episode.objects.get_or_create_for_url(
  82             self.podcast1, 'http://example.com/merge-test-episode1.mp3',
  83             defaults={
  84                 'title': 'Episode 1 A',
  85             })
  86         self.episode2 = Episode.objects.get_or_create_for_url(
  87             self.podcast2, 'http://example.com/merge-test-episode1.mp3',
  88             defaults={
  89                 'title': 'Episode 1 B',
  90             })
  91
  92         User = get_user_model()
  93         self.user = User(username='test-merge')
  94         self.user.email = 'test-merge-tests@example.com'
  95         self.user.set_password('secret!')
  96         self.user.save()
  97
  98     def test_merge_podcasts(self):
  99
 100         action1 = EpisodeHistoryEntry.create_entry(
 101             self.user,
 102             self.episode1,
 103             EpisodeHistoryEntry.PLAY,
 104         )
 105
 106         action2 = EpisodeHistoryEntry.create_entry(
 107             self.user,
 108             self.episode2,
 109             EpisodeHistoryEntry.DOWNLOAD,
 110         )
 111
 112         # decide which episodes to merge
 113         groups = [(0, [self.episode1, self.episode2])]
 114         counter = Counter()
 115
 116         pm = PodcastMerger([self.podcast1, self.podcast2], counter, groups)
 117         pm.merge()
 118
 119         history = EpisodeHistoryEntry.objects.filter(
 120             episode=self.episode1,
 121             user=self.user,
 122         )
 123
 124         # both actions must be present for the merged episode
 125         self.assertIn(action1, history)
 126         self.assertIn(action2, history)
 127
 128     def tearDown(self):
 129         self.episode1.delete()
 130         self.podcast1.delete()
 131         self.user.delete()
 132
 133
 134 class MergeGroupTests(TransactionTestCase):
 135     """ Tests merging of two podcasts, one of which is part of a group """
 136
 137     def setUp(self):
 138         self.podcast1 = Podcast.objects.get_or_create_for_url(
 139             'http://example.com/group-merge-feed.rss',
 140             defaults={
 141                 'title': 'Podcast 1',
 142             },
 143         )
 144         self.podcast2 = Podcast.objects.get_or_create_for_url(
 145             'http://test.org/group-merge-podcast/',
 146             defaults={
 147                 'title': 'Podcast 2',
 148             },
 149         )
 150         self.podcast3 = Podcast.objects.get_or_create_for_url(
 151             'http://group-test.org/feed/',
 152             defaults={
 153                 'title': 'Podcast 3',
 154             },
 155         )
 156
 157         self.episode1 = Episode.objects.get_or_create_for_url(
 158             self.podcast1, 'http://example.com/group-merge-episode1.mp3',
 159             defaults={
 160                 'title': 'Episode 1 A',
 161             },
 162         )
 163         self.episode2 = Episode.objects.get_or_create_for_url(
 164             self.podcast2, 'http://example.com/group-merge-episode1.mp3',
 165             defaults={
 166                 'title': 'Episode 1 B',
 167             },
 168         )
 169         self.episode3 = Episode.objects.get_or_create_for_url(
 170             self.podcast3, 'http://example.com/group-merge-media.mp3',
 171             defaults={
 172                 'title': 'Episode 2',
 173             },
 174         )
 175
 176         self.podcast2.group_with(self.podcast3, 'My Group', 'Feed1', 'Feed2')
 177
 178         User = get_user_model()
 179         self.user = User(username='test-merge-group')
 180         self.user.email = 'test-merge-group-tests@example.com'
 181         self.user.set_password('secret!')
 182         self.user.save()
 183
 184     def test_merge_podcasts(self):
 185         podcast1 = Podcast.objects.get(pk=self.podcast1.pk)
 186         podcast2 = Podcast.objects.get(pk=self.podcast2.pk)
 187         podcast3 = Podcast.objects.get(pk=self.podcast3.pk)
 188
 189         # assert that the podcasts are actually grouped
 190         self.assertEqual(podcast2.group, podcast3.group)
 191
 192         action1 = EpisodeHistoryEntry.create_entry(
 193             self.user,
 194             self.episode1,
 195             EpisodeHistoryEntry.PLAY,
 196         )
 197
 198         action2 = EpisodeHistoryEntry.create_entry(
 199             self.user,
 200             self.episode2,
 201             EpisodeHistoryEntry.DOWNLOAD,
 202         )
 203
 204         # decide which episodes to merge
 205         groups = [(0, [self.episode1, self.episode2])]
 206         counter = Counter()
 207
 208         episode2_id = self.episode2.id
 209
 210         pm = PodcastMerger([podcast2, podcast1], counter, groups)
 211         pm.merge()
 212
 213         history = EpisodeHistoryEntry.objects.filter(
 214             episode = self.episode1,
 215             user = self.user,
 216         )
 217
 218         self.assertIn(action1, history)
 219         self.assertIn(action2, history)
 220
 221         episode1 = Episode.objects.get(pk=self.episode1.pk)
 222
 223         # episode2 has been merged into episode1, so it must contain its
 224         # merged _id
 225         self.assertEqual([x.uuid for x in episode1.merged_uuids.all()],
 226                          [episode2_id])
 227
 228     def tearDown(self):
 229         self.episode1.delete()
 230         self.podcast2.delete()
 231         self.user.delete()
 232
 233
 234 def load_tests(loader, tests, ignore):
 235     tests.addTest(unittest.TestLoader().loadTestsFromTestCase(MergeTests))
 236     tests.addTest(unittest.TestLoader().loadTestsFromTestCase(MergeGroupTests))
 237     return tests