class MergeTests(TestCase):
def setUp(self):
self.podcast1 = Podcast(urls=['http://example.com/feed.rss'])
self.podcast2 = Podcast(urls=['http://test.org/podcast/'])
self.podcast1.save()
self.podcast2.save()
self.episode1 = Episode(podcast=self.podcast1.get_id(),
urls = ['http://example.com/episode1.mp3'])
self.episode2 = Episode(podcast=self.podcast2.get_id(),
urls = ['http://example.com/episode1.mp3'])
self.episode1.save()
self.episode2.save()
self.user = User(username='******')
self.user.email = '*****@*****.**'
self.user.set_password('secret!')
self.user.save()
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 tearDown(self):
self.podcast1.delete()
self.episode1.delete()
try:
self.podcast2.delete()
self.episode2.delete()
except:
pass
self.user.delete()
class PodcastGroupTests(unittest.TestCase):
def test_group(self):
self.podcast1 = Podcast(urls=['http://example1.com'])
self.podcast1.save()
self.podcast2 = Podcast(urls=['http://example2.com'])
self.podcast2.save()
group = self.podcast1.group_with(self.podcast2, 'My Group', 'p1', 'p2')
self.assertIn(self.podcast1, group.podcasts)
self.assertIn(self.podcast2, group.podcasts)
self.assertEquals(len(group.podcasts), 2)
self.assertEquals(group.title, 'My Group')
self.assertEquals(self.podcast1.group_member_name, 'p1')
self.assertEquals(self.podcast2.group_member_name, 'p2')
# add to group
self.podcast3 = Podcast(urls=['http://example3.com'])
self.podcast3.save()
group = self.podcast1.group_with(self.podcast3, 'My Group', 'p1', 'p3')
self.assertIn(self.podcast3, group.podcasts)
self.assertEquals(self.podcast3.group_member_name, 'p3')
# add group to podcast
self.podcast4 = Podcast(urls=['http://example4.com'])
self.podcast4.save()
group = self.podcast4.group_with(self.podcast1, 'My Group', 'p4', 'p1')
self.assertIn(self.podcast4, group.podcasts)
self.assertEquals(self.podcast4.group_member_name, 'p4')
class PodcastGroupTests(unittest.TestCase):
def test_group(self):
self.podcast1 = Podcast(urls=["http://example1.com"])
self.podcast1.save()
self.podcast2 = Podcast(urls=["http://example2.com"])
self.podcast2.save()
group = self.podcast1.group_with(self.podcast2, "My Group", "p1", "p2")
self.assertIn(self.podcast1, group.podcasts)
self.assertIn(self.podcast2, group.podcasts)
self.assertEquals(len(group.podcasts), 2)
self.assertEquals(group.title, "My Group")
self.assertEquals(self.podcast1.group_member_name, "p1")
self.assertEquals(self.podcast2.group_member_name, "p2")
# add to group
self.podcast3 = Podcast(urls=["http://example3.com"])
self.podcast3.save()
group = self.podcast1.group_with(self.podcast3, "My Group", "p1", "p3")
self.assertIn(self.podcast3, group.podcasts)
self.assertEquals(self.podcast3.group_member_name, "p3")
# add group to podcast
self.podcast4 = Podcast(urls=["http://example4.com"])
self.podcast4.save()
group = self.podcast4.group_with(self.podcast1, "My Group", "p4", "p1")
self.assertIn(self.podcast4, group.podcasts)
self.assertEquals(self.podcast4.group_member_name, "p4")
class UnsubscribeMergeTests(TestCase):
""" Test if merged podcasts can be properly unsubscribed
TODO: this test fails intermittently """
P2_URL = 'http://test.org/podcast/'
def setUp(self):
self.podcast1 = Podcast(urls=['http://example.com/feed.rss'])
self.podcast2 = Podcast(urls=[self.P2_URL])
self.podcast1.save()
self.podcast2.save()
self.user = User(username='******')
self.user.email = '*****@*****.**'
self.user.set_password('secret!')
self.user.save()
self.device = get_device(self.user, 'dev', '')
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 tearDown(self):
self.podcast1.delete()
self.user.delete()
def podcast_for_url(url, create=False):
if not url:
raise QueryParameterMissing('url')
key = 'podcast-by-url-%s' % sha1(url.encode('utf-8')).hexdigest()
podcast = cache.get(key)
if podcast:
return podcast
db = get_main_database()
podcast_group = get_single_result(db, 'podcasts/by_url',
key = url,
include_docs = True,
wrapper = _wrap_pg,
)
if podcast_group:
podcast = podcast_group.get_podcast_by_url(url)
if podcast.needs_update:
incomplete_obj.send_robust(sender=podcast)
else:
cache.set(key, podcast)
return podcast
if create:
podcast = Podcast()
podcast.created_timestamp = get_timestamp(datetime.utcnow())
podcast.urls = [url]
podcast.save()
incomplete_obj.send_robust(sender=podcast)
return podcast
return None
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)
class MergeTests(TestCase):
""" Tests merging of two podcasts, their episodes and states """
def setUp(self):
self.podcast1 = Podcast(urls=['http://example.com/feed.rss'])
self.podcast2 = Podcast(urls=['http://test.org/podcast/'])
self.podcast1.save()
self.podcast2.save()
self.episode1 = Episode(podcast=self.podcast1.get_id(),
urls = ['http://example.com/episode1.mp3'])
self.episode2 = Episode(podcast=self.podcast2.get_id(),
urls = ['http://example.com/episode1.mp3'])
self.episode1.save()
self.episode2.save()
self.user = User(username='******')
self.user.email = '*****@*****.**'
self.user.set_password('secret!')
self.user.save()
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 tearDown(self):
self.podcast1.delete()
self.episode1.delete()
#self.podcast2.delete()
#self.episode2.delete()
self.user.delete()
class MergeGroupTests(TestCase):
""" Tests merging of two podcasts, one of which is part of a group """
def setUp(self):
self.podcast1 = Podcast(urls=['http://example.com/feed.rss'])
self.podcast2 = Podcast(urls=['http://test.org/podcast/'])
self.podcast3 = Podcast(urls=['http://test.org/feed/'])
self.podcast1.save()
self.podcast2.save()
self.podcast3.save()
self.episode1 = Episode(podcast=self.podcast1.get_id(),
urls = ['http://example.com/episode1.mp3'])
self.episode2 = Episode(podcast=self.podcast2.get_id(),
urls = ['http://example.com/episode1.mp3'])
self.episode3 = Episode(podcast=self.podcast3.get_id(),
urls = ['http://example.com/media.mp3'])
self.episode1.save()
self.episode2.save()
self.episode3.save()
self.podcast2.group_with(self.podcast3, 'My Group', 'Feed1', 'Feed2')
self.user = User(username='******')
self.user.email = '*****@*****.**'
self.user.set_password('secret!')
self.user.save()
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 tearDown(self):
self.podcast2.delete()
self.episode1.delete()
#self.podcast2.delete()
#self.episode2.delete()
self.user.delete()