def test_podcast_file_sync(self):
# download only one podcast episode
with utils.temp_podcast(self.client, archive_type='soundcloud', max_allowed=1) as podcast:
url = urls.soundcloud_track_list(podcast['broadcast_id'],
self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_one_track.DATA))
self.client.episode_sync()
episode_list = self.client.episode_list(only_files=False)
with utils.temp_audio_file() as mp3_body:
utils.mock_mp3_download(episode_list[0]['download_url'], mp3_body)
self.client.podcast_file_sync()
episode_list = self.client.episode_list()
self.assert_not_none(episode_list[0]['file_path'])
first_episode_date = episode_list[0]['date']
# add an additional, newer podcast, make sure things are deleted
url = urls.soundcloud_track_list(podcast['broadcast_id'],
self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_two_tracks.DATA))
self.client.episode_sync()
episode_list = self.client.episode_list(only_files=False)
with utils.temp_audio_file() as mp3_body:
utils.mock_mp3_download(episode_list[1]['download_url'], mp3_body)
self.client.podcast_file_sync()
# make sure 2 episodes in db, but only 1 with a file path
episode_list = self.client.episode_list()
self.assert_not_none(episode_list[0]['file_path'])
all_episodes = self.client.episode_list(only_files=False)
self.assertNotEqual(len(episode_list), len(all_episodes))
second_episode_date = episode_list[0]['date']
self.assertTrue(datetime.strptime(second_episode_date, self.client.datetime_output_format) >
datetime.strptime(first_episode_date, self.client.datetime_output_format))
def test_episode_prevent_deletion(self):
# download only one podcast episode
with test_utils.temp_podcast(self.client, archive_type="soundcloud", max_allowed=1) as podcast:
url = urls.soundcloud_track_list(podcast["broadcast_id"], self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_one_track.DATA))
self.client.episode_sync()
episode_list = self.client.episode_list(only_files=False)
with test_utils.temp_audio_file() as mp3_body:
test_utils.mock_mp3_download(episode_list[0]["download_url"], mp3_body)
self.client.podcast_file_sync()
# mark episode to prevent deletion
self.client.episode_update(episode_list[0]["id"], prevent_delete=True)
# add an additional, newer podcast, make sure prevented deletion episode stays
url = urls.soundcloud_track_list(podcast["broadcast_id"], self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_three_tracks.DATA))
self.client.episode_sync(max_episode_sync=0)
episode_list = self.client.episode_list(only_files=False)
test_utils.mock_mp3_download(episode_list[1]["download_url"], mp3_body)
test_utils.mock_mp3_download(episode_list[2]["download_url"], mp3_body)
self.client.podcast_file_sync()
episode_list = self.client.episode_list()
ep_ids = [i["id"] for i in episode_list]
self.assertTrue(2 in ep_ids)
self.assertTrue(1 in ep_ids)
self.assertTrue(3 not in ep_ids)
def test_soundcloud_broadcast_update_skip_cant_download(self):
sound_id = '123'
broadcast = 'foo'
manager = SoundcloudManager(logging, sound_id, None)
url = urls.soundcloud_track_list(broadcast, sound_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_one_track_cant_download.DATA))
episodes = manager.broadcast_update(broadcast)
self.assert_length(episodes, 0)
def test_soundcloud_error_status_not_200(self):
sound_id = '123'
broadcast = 'foo'
manager = SoundcloudManager(logging, sound_id, None)
url = urls.soundcloud_track_list(broadcast, sound_id)
code = 400
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_one_track.DATA), status=code)
with self.assertRaises(HathorException) as error:
manager.broadcast_update(broadcast)
self.assertTrue('Error getting soundcloud track list, request error:%s' % code, error)
def test_podcast_file_sync_no_automatic_episode_download(self):
# make sure no max allowed downloads all possible podcasts
with utils.temp_podcast(self.client, archive_type='soundcloud', max_allowed=None, automatic_download=False) as podcast:
url = urls.soundcloud_track_list(podcast['broadcast_id'],
self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_one_track_only_page.DATA))
self.client.episode_sync()
episode_list = self.client.episode_list(only_files=False)
with utils.temp_audio_file() as mp3_body:
utils.mock_mp3_download(episode_list[0]['download_url'], mp3_body)
self.client.podcast_file_sync()
episode_list = self.client.episode_list()
self.assert_length(episode_list, 0)
def test_episode_sync_soundcloud_max_allowed(self):
# make sure you only get the one page from soundcloud pagination
with test_utils.temp_podcast(self.client, archive_type="soundcloud", max_allowed=2) as podcast:
page1_url = urls.soundcloud_track_list(podcast["broadcast_id"], self.client.soundcloud_client_id)
httpretty.register_uri(
httpretty.GET,
page1_url,
body=json.dumps(soundcloud_archive_page1.DATA),
content_type="application/json",
)
self.client.episode_sync()
episode_list = self.client.episode_list(only_files=False)
self.assertEqual(len(episode_list), 2)
def test_podcast_dont_delete_episode_files(self):
with utils.temp_podcast(self.client, archive_type='soundcloud', max_allowed=1) as podcast:
url = urls.soundcloud_track_list(podcast['broadcast_id'],
self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_one_track.DATA))
self.client.episode_sync()
episode_list = self.client.episode_list(only_files=False)
with utils.temp_audio_file() as mp3_body:
utils.mock_mp3_download(episode_list[0]['download_url'], mp3_body)
self.client.podcast_file_sync()
episode_list = self.client.episode_list()
# delete and make sure file is still there
self.client.podcast_delete(podcast['id'], delete_files=False)
self.assertTrue(len(os.listdir(podcast['file_location'])) > 0)
os.remove(episode_list[0]['file_path'])
os.rmdir(podcast['file_location'])
def test_podcast_file_sync_exclude(self):
# create two podcasts, exclude one, make sure only that pod was updated
with utils.temp_podcast(self.client, archive_type='soundcloud', max_allowed=1) as podcast1:
url = urls.soundcloud_track_list(podcast1['broadcast_id'],
self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_one_track.DATA))
self.client.episode_sync()
episode_list = self.client.episode_list(only_files=False)
with utils.temp_audio_file() as mp3_body:
utils.mock_mp3_download(episode_list[0]['download_url'], mp3_body)
with utils.temp_podcast(self.client) as podcast2:
self.client.podcast_file_sync(exclude_podcasts=[podcast2['id']], )
episode_list = self.client.episode_list()
self.assertTrue(len(episode_list) > 0)
for episode in episode_list:
self.assertEqual(podcast1['id'], episode['podcast_id'])
def test_episode_sync_set_number_episodes(self):
with test_utils.temp_podcast(self.client, archive_type="soundcloud", max_allowed=2) as podcast:
page1_url = urls.soundcloud_track_list(podcast["broadcast_id"], self.client.soundcloud_client_id)
httpretty.register_uri(
httpretty.GET,
page1_url,
body=json.dumps(soundcloud_archive_page1.DATA),
content_type="application/json",
)
page2_url = soundcloud_archive_page1.DATA["next_href"]
httpretty.register_uri(
httpretty.GET,
page2_url,
body=json.dumps(soundcloud_archive_page2.DATA),
content_type="application/json",
)
self.client.episode_sync(max_episode_sync=3)
episode_list = self.client.episode_list(only_files=False)
self.assertEqual(len(episode_list), 3)
def test_podcast_database_cleanup(self):
# download only one podcast episode
with test_utils.temp_podcast(self.client, archive_type="soundcloud", max_allowed=1) as podcast:
url = urls.soundcloud_track_list(podcast["broadcast_id"], self.client.soundcloud_client_id)
httpretty.register_uri(httpretty.GET, url, body=json.dumps(soundcloud_two_tracks.DATA))
self.client.episode_sync(max_episode_sync=0)
episode_list = self.client.episode_list(only_files=False)
with test_utils.temp_audio_file() as mp3_body:
test_utils.mock_mp3_download(episode_list[0]["download_url"], mp3_body)
self.client.podcast_file_sync()
episode_list = self.client.episode_list()
self.assert_not_none(episode_list[0]["file_path"])
all_episodes = self.client.episode_list(only_files=False)
self.assertTrue(len(all_episodes) > 1)
self.client.database_cleanup()
all_episodes = self.client.episode_list(only_files=False)
self.assert_length(all_episodes, 1)
def test_episode_list_exclude_podcast_filter(self):
with test_utils.temp_podcast(self.client, archive_type="rss", broadcast_url=True) as podcast1:
httpretty.register_uri(httpretty.GET, podcast1["broadcast_id"], body=history_on_fire.DATA)
with test_utils.temp_podcast(self.client, archive_type="soundcloud", max_allowed=2) as podcast2:
page1_url = urls.soundcloud_track_list(podcast2["broadcast_id"], self.client.soundcloud_client_id)
httpretty.register_uri(
httpretty.GET,
page1_url,
body=json.dumps(soundcloud_archive_page1.DATA),
content_type="application/json",
)
self.client.episode_sync()
episode_list_all = self.client.episode_list(only_files=False)
episode_list_exc = self.client.episode_list(only_files=False, exclude_podcasts=[podcast2["id"]])
self.assertNotEqual(len(episode_list_all), len(episode_list_exc))
for episode in episode_list_exc:
self.assertEqual(episode["podcast_id"], podcast1["id"])
def broadcast_update(self, broadcast_id, max_results=None, filters=None):
self.logger.debug("Getting episodes from soundcloud broadcast:%s", broadcast_id)
url = urls.soundcloud_track_list(broadcast_id, self.soundcloud_client_id)
archive_data = []
filters = filters or []
while True:
req = requests.get(url)
if req.status_code != 200:
raise HathorException("Error getting soundcloud track list, request error:%s" % req.status_code)
data = json.loads(req.text)
for item in data["collection"]:
# if not downloadable, skip
if not item["downloadable"]:
self.logger.debug("Item with title:%s not downloadable, skipping", item["title"])
continue
episode_data = {
"date": datetime.strptime(item["created_at"], "%Y/%m/%d %H:%M:%S +0000"),
"title": utils.clean_string(item["title"]),
"download_link": utils.clean_string(item["download_url"]),
"description": utils.clean_string(item["description"]),
}
if not verify_title_filters(filters, episode_data["title"]):
self.logger.debug("Title:%s , does not pass filters, skipping", episode_data["title"])
continue
archive_data.append(episode_data)
if max_results and max_results <= len(archive_data):
self.logger.debug("At max results limit:%s, exiting early", len(archive_data))
return archive_data
# check if another page is there
try:
url = data["next_href"]
except KeyError:
self.logger.debug("No more soundcloud episodes found, exiting")
break
return archive_data
