def test_merge_podcasts(self):
action1 = EpisodeHistoryEntry.create_entry(
self.user,
self.episode1,
EpisodeHistoryEntry.PLAY,
)
action2 = EpisodeHistoryEntry.create_entry(
self.user,
self.episode2,
EpisodeHistoryEntry.DOWNLOAD,
)
# decide which episodes to merge
groups = [(0, [self.episode1, self.episode2])]
counter = Counter()
pm = PodcastMerger([self.podcast1, self.podcast2], counter, groups)
pm.merge()
history = EpisodeHistoryEntry.objects.filter(
episode=self.episode1,
user=self.user,
)
# both actions must be present for the merged episode
self.assertIn(action1, history)
self.assertIn(action2, history)
def test_merge_podcasts(self):
action1 = EpisodeHistoryEntry.create_entry(
self.user,
self.episode1,
EpisodeHistoryEntry.PLAY,
)
action2 = EpisodeHistoryEntry.create_entry(
self.user,
self.episode2,
EpisodeHistoryEntry.DOWNLOAD,
)
# decide which episodes to merge
groups = [(0, [self.episode1, self.episode2])]
counter = Counter()
pm = PodcastMerger([self.podcast1, self.podcast2], counter, groups)
pm.merge()
history = EpisodeHistoryEntry.objects.filter(
episode=self.episode1,
user=self.user,
)
# both actions must be present for the merged episode
self.assertIn(action1, history)
self.assertIn(action2, history)
def test_merge_podcasts(self):
podcast1 = Podcast.objects.get(pk=self.podcast1.pk)
podcast2 = Podcast.objects.get(pk=self.podcast2.pk)
podcast3 = Podcast.objects.get(pk=self.podcast3.pk)
# assert that the podcasts are actually grouped
self.assertEqual(podcast2.group, podcast3.group)
action1 = EpisodeHistoryEntry.create_entry(self.user, self.episode1,
EpisodeHistoryEntry.PLAY)
action2 = EpisodeHistoryEntry.create_entry(
self.user, self.episode2, EpisodeHistoryEntry.DOWNLOAD)
# decide which episodes to merge
groups = [(0, [self.episode1.id, self.episode2.id])]
counter = Counter()
episode2_id = self.episode2.id
pm = PodcastMerger([podcast2, podcast1], counter, groups)
pm.merge()
history = EpisodeHistoryEntry.objects.filter(episode=self.episode1,
user=self.user)
self.assertIn(action1, history)
self.assertIn(action2, history)
episode1 = Episode.objects.get(pk=self.episode1.pk)
# episode2 has been merged into episode1, so it must contain its
# merged _id
self.assertEqual([x.uuid for x in episode1.merged_uuids.all()],
[episode2_id])
def test_merge_podcasts(self):
# Create additional data that will be merged
state1 = episode_state_for_user_episode(self.user, self.episode1)
state2 = episode_state_for_user_episode(self.user, self.episode2)
action1 = EpisodeAction(action='play',
timestamp=datetime.utcnow(),
upload_timestamp=get_timestamp(datetime.utcnow()))
action2 = EpisodeAction(action='download',
timestamp=datetime.utcnow(),
upload_timestamp=get_timestamp(datetime.utcnow()))
add_episode_actions(state1, [action1])
add_episode_actions(state2, [action2])
# copy of the object
episode2 = episode_by_id(self.episode2._id)
# decide which episodes to merge
groups = [(0, [self.episode1, self.episode2])]
counter = Counter()
pm = PodcastMerger([self.podcast1, self.podcast2], counter, groups)
pm.merge()
state1 = episode_state_for_user_episode(self.user, self.episode1)
state2 = episode_state_for_user_episode(self.user, episode2)
self.assertIn(action1, state1.actions)
self.assertIn(action2, state1.actions)
self.assertEqual(state2._id, None)
def test_merge_podcasts(self):
subscribe(self.podcast2, self.user, self.device)
# merge podcast2 into podcast1
pm = PodcastMerger([self.podcast1, self.podcast2], Counter(), [])
pm.merge()
# get podcast for URL of podcast2 and unsubscribe from it
p = Podcast.objects.get(urls__url=self.P2_URL)
unsubscribe(p, self.user, self.device)
subscriptions = Podcast.objects.filter(subscription__user=self.user)
self.assertEqual(0, len(subscriptions))
def test_merge_podcasts(self):
subscribe(self.podcast2, self.user, self.device)
# merge podcast2 into podcast1
pm = PodcastMerger([self.podcast1, self.podcast2], Counter(), [])
pm.merge()
# get podcast for URL of podcast2 and unsubscribe from it
p = Podcast.objects.get(urls__url=self.P2_URL)
unsubscribe(p, self.user, self.device)
subscriptions = Podcast.objects.filter(subscription__user=self.user)
self.assertEqual(0, len(subscriptions))
def test_merge_podcasts(self):
podcast1 = podcast_by_id(self.podcast1.get_id())
podcast2 = podcast_by_id(self.podcast2.get_id())
podcast3 = podcast_by_id(self.podcast3.get_id())
# assert that the podcasts are actually grouped
self.assertEqual(podcast2._id, podcast3._id)
self.assertNotEqual(podcast2.get_id(), podcast2._id)
self.assertNotEqual(podcast3.get_id(), podcast3._id)
# Create additional data that will be merged
state1 = episode_state_for_user_episode(self.user, self.episode1)
state2 = episode_state_for_user_episode(self.user, self.episode2)
action1 = EpisodeAction(action='play',
timestamp=datetime.utcnow(),
upload_timestamp=get_timestamp(datetime.utcnow()))
action2 = EpisodeAction(action='download',
timestamp=datetime.utcnow(),
upload_timestamp=get_timestamp(datetime.utcnow()))
add_episode_actions(state1, [action1])
add_episode_actions(state2, [action2])
# copy of the object
episode2 = episode_by_id(self.episode2._id)
# decide which episodes to merge
groups = [(0, [self.episode1, self.episode2])]
counter = Counter()
pm = PodcastMerger([podcast2, podcast1], counter, groups)
pm.merge()
state1 = episode_state_for_user_episode(self.user, self.episode1)
state2 = episode_state_for_user_episode(self.user, episode2)
self.assertIn(action1, state1.actions)
self.assertIn(action2, state1.actions)
self.assertEqual(state2._id, None)
episode1 = episode_by_id(self.episode1._id)
# episode2 has been merged into episode1, so it must contain its
# merged _id
self.assertEqual(episode1.merged_ids, [episode2._id])
def merge_podcasts(podcast_ids, num_groups):
""" Task to merge some podcasts"""
logger.info("merging podcast ids %s", podcast_ids)
podcasts = podcasts_by_id(podcast_ids)
logger.info("merging podcasts %s", podcasts)
actions = Counter()
pm = PodcastMerger(podcasts, actions, num_groups)
podcast = pm.merge()
logger.info("merging result: %s", actions)
return actions, podcast
def post(self, request):
try:
podcasts = self._get_podcasts(request)
except InvalidPodcast as ip:
messages.error(request,
_('No podcast with URL {url}').format(url=str(ip)))
grouper = PodcastGrouper(podcasts)
features = {}
for key, feature in request.POST.items():
m = self.RE_EPISODE.match(key)
if m:
episode_id = m.group(1)
features[episode_id] = feature
get_features = lambda (e_id, e): (features[e_id], e_id)
num_groups = grouper.group(get_features)
if 'renew' in request.POST:
return render(request, 'admin/merge-grouping.html', {
'podcasts': podcasts,
'groups': num_groups,
})
elif 'merge' in request.POST:
actions = Counter()
try:
# merge podcast, reassign episodes
pm = PodcastMerger(podcasts, actions, num_groups)
pm.merge()
except IncorrectMergeException as ime:
messages.error(request, str(ime))
return HttpResponseRedirect(reverse('admin-merge'))
return render(request, 'admin/merge-finished.html', {
'actions': actions.items(),
'podcast': podcasts[0],
})
def merge_podcasts(podcast_ids, num_groups):
""" Task to merge some podcasts"""
logger.info('merging podcast ids %s', podcast_ids)
podcasts = list(Podcast.objects.filter(id__in=podcast_ids))
logger.info('merging podcasts %s', podcasts)
actions = Counter()
pm = PodcastMerger(podcasts, actions, num_groups)
podcast = pm.merge()
logger.info('merging result: %s', actions)
return actions, podcast
def merge_podcasts(podcast_ids, num_groups):
""" Task to merge some podcasts"""
logger.info('merging podcast ids %s', podcast_ids)
podcasts = list(Podcast.objects.filter(id__in=podcast_ids))
logger.info('merging podcasts %s', podcasts)
actions = Counter()
pm = PodcastMerger(podcasts, actions, num_groups)
podcast = pm.merge()
logger.info('merging result: %s', actions)
return actions, podcast
def test_merge_podcasts(self):
podcast1 = Podcast.objects.get(pk=self.podcast1.pk)
podcast2 = Podcast.objects.get(pk=self.podcast2.pk)
podcast3 = Podcast.objects.get(pk=self.podcast3.pk)
# assert that the podcasts are actually grouped
self.assertEqual(podcast2.group, podcast3.group)
action1 = EpisodeHistoryEntry.create_entry(
self.user,
self.episode1,
EpisodeHistoryEntry.PLAY,
)
action2 = EpisodeHistoryEntry.create_entry(
self.user,
self.episode2,
EpisodeHistoryEntry.DOWNLOAD,
)
# decide which episodes to merge
groups = [(0, [self.episode1, self.episode2])]
counter = Counter()
episode2_id = self.episode2.id
pm = PodcastMerger([podcast2, podcast1], counter, groups)
pm.merge()
history = EpisodeHistoryEntry.objects.filter(
episode = self.episode1,
user = self.user,
)
self.assertIn(action1, history)
self.assertIn(action2, history)
episode1 = Episode.objects.get(pk=self.episode1.pk)
# episode2 has been merged into episode1, so it must contain its
# merged _id
self.assertEqual([x.uuid for x in episode1.merged_uuids.all()],
[episode2_id])
def test_merge_podcasts(self):
self.podcast2.subscribe(self.user, self.device)
# merge podcast2 into podcast1
pm = PodcastMerger([self.podcast1, self.podcast2], Counter(), [])
pm.merge()
# seems that setting delayed_commit = false in the CouchDB config, as
# well as a delay here fix the intermittent failures.
# TODO: further investiation needed
import time
time.sleep(2)
# get podcast for URL of podcast2 and unsubscribe from it
p = podcast_for_url(self.P2_URL)
p.unsubscribe(self.user, self.device)
subscriptions = subscribed_podcast_ids_by_user_id(self.user._id)
self.assertEqual(0, len(subscriptions))
def test_merge_podcasts(self):
state1 = self.episode1.get_user_state(self.user)
state2 = self.episode2.get_user_state(self.user)
action1 = EpisodeAction(action='play', timestamp=datetime.utcnow())
action2 = EpisodeAction(action='download', timestamp=datetime.utcnow())
state1.add_actions([action1])
state2.add_actions([action2])
state1.save()
state2.save()
pm = PodcastMerger([self.podcast1, self.podcast2])
pm.merge()
state1 = self.episode1.get_user_state(self.user)
state2 = self.episode2.get_user_state(self.user)
self.assertIn(action1, state1.actions)
self.assertIn(action2, state1.actions)
def test_merge(self):
p1 = Podcast.objects.get_or_create_for_url(
"http://example.com/podcast1.rss"
).object
p2 = Podcast.objects.get_or_create_for_url(
"http://example.com/podcast2.rss"
).object
e1 = Episode.objects.get_or_create_for_url(
p1, "http://example.com/podcast1/e1.mp3"
).object
e1.title = "Episode 1"
e1.save()
e2 = Episode.objects.get_or_create_for_url(
p2, "http://example.com/podcast1/e2.mp3"
).object
e2.title = "Episode 2"
e2.save()
e3 = Episode.objects.get_or_create_for_url(
p2, "http://example.com/podcast2/e2.mp3"
).object
e3.title = "Episode 3"
e3.save()
e4 = Episode.objects.get_or_create_for_url(
p2, "http://example.com/podcast2/e3.mp3"
).object
e4.title = "Episode 4"
e4.save()
User = get_user_model()
user = User()
user.username = "******"
user.email = "*****@*****.**"
user.set_password("secret")
user.save()
device1 = Client.objects.create(user=user, uid="dev1", id=uuid.uuid1())
device2 = Client.objects.create(user=user, uid="dev2", id=uuid.uuid1())
subscribe(p1.pk, user.pk, device1.uid)
unsubscribe(p1.pk, user.pk, device1.uid)
subscribe(p1.pk, user.pk, device1.uid)
subscribe(p2.pk, user.pk, device2.uid)
action1 = EpisodeHistoryEntry.create_entry(user, e1, EpisodeHistoryEntry.PLAY)
action3 = EpisodeHistoryEntry.create_entry(user, e3, EpisodeHistoryEntry.PLAY)
# we need that for later
e3_id = e3.pk
actions = Counter()
# decide which episodes to merge
groups = [(0, [e1.id]), (1, [e2.id, e3.id]), (2, [e4.id])]
# carry out the merge
pm = PodcastMerger([p1, p2], actions, groups)
pm.merge()
e1 = Episode.objects.get(pk=e1.pk)
history1 = EpisodeHistoryEntry.objects.filter(episode=e1, user=user)
self.assertEqual(len(history1), 1)
# check if merged episode's id can still be accessed
e3 = Episode.objects.filter(podcast=p1).get_by_any_id(e3_id)
history3 = EpisodeHistoryEntry.objects.filter(episode=e3, user=user)
self.assertEqual(len(history3), 1)
p1 = Podcast.objects.get(pk=p1.get_id())
subscribed_clients = Client.objects.filter(subscription__podcast=p1)
self.assertEqual(len(subscribed_clients), 2)
episodes = p1.episode_set.all()
self.assertEqual(len(episodes), 3)
def test_merge(self):
p1 = Podcast()
p1.urls = ['http://example.com/podcast1.rss']
p1.save()
p2 = Podcast()
p2.urls = ['http://example.com/podcast2.rss']
p2.save()
e1 = Episode()
e1.title = 'Episode 1'
e1.podcast = p1.get_id()
e1.urls = ['http://example.com/podcast1/e1.mp3']
e1.save()
e2 = Episode()
e2.title = 'Episode 2'
e2.podcast = p1.get_id()
e2.urls = ['http://example.com/podcast1/e2.mp3']
e2.save()
e3 = Episode()
e3.title = 'Episode 3'
e3.podcast = p2.get_id()
e3.urls = ['http://example.com/podcast2/e2.mp3']
e3.save()
e4 = Episode()
e4.title = 'Episode 4'
e4.podcast = p2.get_id()
e4.urls = ['http://example.com/podcast2/e3.mp3']
e4.save()
user = User()
user.username = '******'
user.email = '*****@*****.**'
user.set_password('secret')
device1 = Device()
device1.uid = 'dev1'
device2 = Device()
device2.uid = 'dev2'
user.devices.append(device1)
user.devices.append(device2)
user.save()
p1.subscribe(user, device1)
time.sleep(1)
p1.unsubscribe(user, device1)
time.sleep(1)
p1.subscribe(user, device1)
p2.subscribe(user, device2)
s1 = e1.get_user_state(user)
s1.add_actions([EpisodeAction(action='play')])
s1.save()
s3 = e3.get_user_state(user)
s3.add_actions([EpisodeAction(action='play')])
s3.save()
# we need that for later
e3_id = e3._id
actions = Counter()
# decide which episodes to merge
groups = [(0, [e1]), (1, [e2, e3]), (2, [e4])]
# carry out the merge
pm = PodcastMerger([p1, p2], actions, groups)
pm.merge()
e1 = Episode.get(e1._id)
es1 = e1.get_user_state(user)
self.assertEqual(len(es1.actions), 1)
# check if merged episode's id can still be accessed
e3 = Episode.get(e3_id)
es3 = e3.get_user_state(user)
self.assertEqual(len(es3.actions), 1)
p1 = Podcast.get(p1.get_id())
ps1 = p1.get_user_state(user)
self.assertEqual(len(ps1.get_subscribed_device_ids()), 2)
self.assertEqual(len(list(p1.get_episodes())), 3)
def test_merge_podcasts(self):
# decide which episodes to merge
groups = [(0, [self.episode1.id, self.episode2.id])]
counter = Counter()
pm = PodcastMerger([self.podcast1, self.podcast2], counter, groups)
pm.merge()
def test_merge_podcasts(self):
# decide which episodes to merge
groups = [(0, [self.episode1, self.episode2])]
counter = Counter()
pm = PodcastMerger([self.podcast1, self.podcast2], counter, groups)
pm.merge()
def test_merge(self):
p1 = Podcast.objects.get_or_create_for_url(
'http://example.com/podcast1.rss'
).object
p2 = Podcast.objects.get_or_create_for_url(
'http://example.com/podcast2.rss'
).object
e1 = Episode.objects.get_or_create_for_url(
p1, 'http://example.com/podcast1/e1.mp3'
).object
e1.title = 'Episode 1'
e1.save()
e2 = Episode.objects.get_or_create_for_url(
p2, 'http://example.com/podcast1/e2.mp3'
).object
e2.title = 'Episode 2'
e2.save()
e3 = Episode.objects.get_or_create_for_url(
p2, 'http://example.com/podcast2/e2.mp3'
).object
e3.title = 'Episode 3'
e3.save()
e4 = Episode.objects.get_or_create_for_url(
p2, 'http://example.com/podcast2/e3.mp3'
).object
e4.title = 'Episode 4'
e4.save()
User = get_user_model()
user = User()
user.username = '******'
user.email = '*****@*****.**'
user.set_password('secret')
user.save()
device1 = Client.objects.create(user=user, uid='dev1', id=uuid.uuid1())
device2 = Client.objects.create(user=user, uid='dev2', id=uuid.uuid1())
subscribe(p1, user, device1)
unsubscribe(p1, user, device1)
subscribe(p1, user, device1)
subscribe(p2, user, device2)
action1 = EpisodeHistoryEntry.create_entry(user, e1, EpisodeHistoryEntry.PLAY)
action3 = EpisodeHistoryEntry.create_entry(user, e3, EpisodeHistoryEntry.PLAY)
# we need that for later
e3_id = e3.pk
actions = Counter()
# decide which episodes to merge
groups = [(0, [e1]), (1, [e2, e3]), (2, [e4])]
# carry out the merge
pm = PodcastMerger([p1, p2], actions, groups)
pm.merge()
e1 = Episode.objects.get(pk=e1.pk)
history1 = EpisodeHistoryEntry.objects.filter(episode=e1, user=user)
self.assertEqual(len(history1), 1)
# check if merged episode's id can still be accessed
e3 = Episode.objects.filter(podcast=p1).get_by_any_id(e3_id)
history3 = EpisodeHistoryEntry.objects.filter(episode=e3, user=user)
self.assertEqual(len(history3), 1)
p1 = Podcast.objects.get(pk=p1.get_id())
subscribed_clients = Client.objects.filter(subscription__podcast=p1)
self.assertEqual(len(subscribed_clients), 2)
episodes = p1.episode_set.all()
self.assertEqual(len(episodes), 3)
