def setUp(self):
super(AlbumMonitorControllerTest, self).setUp()
self.album_id = IdentityService.id_album("name")
self.data_producer.album(self.album_id, "name").video("source1").video(
"source2"
).album(IdentityService.id_album("name2"), "name2").populate(self.data_facade)
self.album_repo = self.data_facade.album_repo
self.albums = self.album_repo.list()
def test_construction(self):
name = "name"
ids = [IdentityService.random()]
thumbnail = "thumbnail"
id = IdentityService.id_album(name)
album = Album(id, name, ids, thumbnail)
self.expect_events(album, Evt.AlbumCreated)
def _create_video(self, cmd):
def impl(ctx, metadata):
video = Video(cmd.model_id, cmd.source, cmd.collection_id,
**metadata)
ctx.add(video)
if Path(cmd.source).is_file():
metadata = self._source_service.pick_file_metadata(Path(
cmd.source))
else:
metadata = self._source_service.pick_stream_metadata(cmd.source)
if metadata is None:
self._abort_operation(cmd.id,
"no media found", {"source": cmd.source},
cmd=cmd)
return
if metadata["duration"]:
metadata["duration"] = timedelta(seconds=metadata["duration"])
if metadata["artist"]:
metadata["artist_id"] = IdentityService.id_artist(
metadata["artist"])
if metadata["album"]:
metadata["album_id"] = IdentityService.id_album(metadata["album"])
del metadata["artist"]
del metadata["album"]
self._start_transaction(self._video_repo, cmd.id, impl, metadata)
def test_construction(self):
collection_id = IdentityService.random()
artist_id = (IdentityService.id_artist("artist"), )
album_id = (IdentityService.id_album("album_name"), )
video = Video(
IdentityService.random(),
"source",
collection_id,
artist_id,
album_id,
"title",
timedelta(seconds=300),
timedelta(),
None,
"protocol",
"thumbnail_url",
"/tmp/file",
[],
"subtitle",
)
self.assertEqual("source", video.source)
self.assertEqual(collection_id, video.collection_id)
self.assertEqual(artist_id, video.artist_id)
self.assertEqual(album_id, video.album_id)
self.assertEqual("title", video.title)
self.assertEqual(300, video.duration)
self.assertEqual("/tmp/file", video.location)
self.assertEqual([], video.streams)
self.assertEqual("subtitle", video.subtitle)
self.expect_events(video, Evt.VideoCreated)
def test_create_video(self):
source = "source"
video_id = IdentityService.id_video(source)
collection_id = IdentityService.random()
metadata = {
"title": "title",
"duration": 300,
"source_protocol": "http",
"artist": "artist",
"album": "album",
"thumbnail": "thumbnail_url",
}
self.downloader.download_metadata.return_value = metadata
self.deezer.search.return_value = []
attrs = deepcopy(metadata)
attrs["artist_id"] = IdentityService.id_artist(attrs.pop("artist"))
attrs["album_id"] = IdentityService.id_album(attrs.pop("album"))
self.evt_expecter.expect(
VideoEvt.VideoCreated,
video_id,
source,
collection_id,
**attrs,
state=VideoState.CREATED,
).from_(Cmd.CreateVideo, video_id, source, collection_id)
def test_create_album_no_deezer_data(self):
video_id = IdentityService.id_video("source")
album_id = IdentityService.id_album("album")
self.data_producer.video("source",
album_id=album_id).populate(self.data_facade)
metadata = {
"title": "title",
"duration": 300,
"source_protocol": "http",
"artist": "artist",
"album": "album",
"thumbnail": "thumbnail_url",
}
self.downloader.download_metadata.return_value = metadata
self.deezer.search.return_value = []
self.evt_expecter.expect(Evt.AlbumCreated, album_id, "album",
[video_id], "thumbnail_url").from_event(
VideoEvt.VideoCreated,
video_id,
"source",
None,
None,
album_id,
"title",
300,
"http",
"thumbnail_url",
VideoState.CREATED,
)
def test_retrieving_to_finalizing(self):
event = Evt.VideoCreated(
IdentityService.random(),
*self.video.to_tuple(),
IdentityService.id_artist("artist"),
IdentityService.id_album("album"),
"title",
300,
"m3u8",
"thumbnail",
VideoState.CREATED,
)
self.workflow.to_RETRIEVING(event)
cmd = self.expect_dispatch(
Cmd.RetrieveVideo, self.video.id, settings["downloader.output_directory"]
)
def return_video(id):
self.assertEqual(self.video.id, id)
return VideoModel(self.video.id, self.video.source, source_protocol="m3u8")
self.video_repo.get.side_effect = return_video
self.raise_event(
Evt.VideoRetrieved,
cmd.id,
self.video.id,
"https://url.m3u8",
)
self.assertTrue(self.workflow.is_FINALIZING())
def test_empty(self):
self.assertTrue(self.album.empty())
self.album = Album(
IdentityService.id_album("name"),
"name",
[IdentityService.random()],
"thumbnail",
)
self.assertFalse(self.album.empty())
def test_delete_video_deletes_album(self):
album_id = IdentityService.id_album("album")
video_id = IdentityService.id_video("source")
self.data_producer.album(album_id, "album").video(
"source", album_id=album_id).populate(self.data_facade)
self.evt_expecter.expect(Evt.AlbumDeleted, album_id, []).from_event(
VideoEvt.VideoDeleted,
video_id,
)
def test_delete_album(self):
name = "name"
album_id = IdentityService.id_album(name)
self.data_producer.album(album_id, name).video("source").populate(
self.data_facade)
album = self.album_repo.get(album_id)
self.evt_expecter.expect(Evt.AlbumDeleted, album.id,
album.ids).from_(Cmd.DeleteAlbum, album.id)
self.assertIsNone(self.album_repo.get(album_id))
def test_creating_to_retrieving(self):
self.workflow.to_CREATING()
cmd = self.expect_dispatch(Cmd.CreateVideo, *self.video.to_tuple())
self.raise_event(
Evt.VideoCreated,
cmd.id,
*self.video.to_tuple(),
IdentityService.id_artist("artist"),
IdentityService.id_album("album"),
"title",
300,
"http",
"thumbnail",
VideoState.CREATED,
)
self.assertTrue(self.workflow.is_RETRIEVING())
def test_encode_domain_event(self):
video_id = IdentityService.id_video("source")
collection_id = None
cmd_id = IdentityService.id_command(CreateVideo, video_id)
event = VideoCreated(
cmd_id,
video_id,
"source",
collection_id,
IdentityService.id_artist("artist"),
IdentityService.id_album("album"),
"title",
300,
"protocol",
"thumbnail",
VideoState.CREATED,
)
json.dumps(event, cls=EventEncoder)
def test_retrieving_to_deleting(self):
event = Evt.VideoCreated(
IdentityService.random(),
*self.video.to_tuple(),
IdentityService.id_artist("artist"),
IdentityService.id_album("album"),
"title",
300,
"http",
"thumbnail",
VideoState.CREATED,
)
self.workflow.to_RETRIEVING(event)
cmd = self.expect_dispatch(
Cmd.RetrieveVideo, self.video.id, settings["downloader.output_directory"]
)
self.raise_error(cmd)
self.assertTrue(self.workflow.is_DELETING())
def test_collecting_to_queueing_with_video_created(self):
(video_workflow, ) = self.expect_workflow_creation(VideoWorkflow)
self.workflow.to_COLLECTING()
video_workflow.start.assert_called_once()
cmd_id = IdentityService.id_command(VideoCmd.CreateVideo,
self.video.id)
self.raise_event(
VideoEvt.VideoCreated,
cmd_id,
self.video.id,
self.video.source,
self.video.collection_id,
IdentityService.id_artist("artist"),
IdentityService.id_album("album"),
"title",
300,
"m3u8",
"thumbnail",
VideoState.CREATED,
)
self.assertTrue(self.workflow.is_QUEUEING())
def test_add_video_updates_album(self):
video_id_1 = IdentityService.id_video("source")
video_id_2 = IdentityService.id_video("source2")
album_id = IdentityService.id_album("album")
self.data_producer.video("source2",
album_id=album_id).populate(self.data_facade)
self.data_producer.album(album_id, "album").video(
"source", album_id=album_id).populate(self.data_facade)
self.evt_expecter.expect(Evt.AlbumVideosUpdated, album_id,
[video_id_1, video_id_2]).from_event(
VideoEvt.VideoCreated,
video_id_2,
"source2",
None,
None,
album_id,
"title",
300,
"http",
"thumbnail",
VideoState.CREATED,
)
def setUp(self):
name = "name"
self.album = Album(IdentityService.id_album(name), name, [],
"thumbnail")
self.album.release_events()
def test_encode_album(self):
name = "name"
album_id = IdentityService.id_album(name)
album = Album(album_id, name, [IdentityService.random()], "thumbnail")
json.dumps(album, cls=ModelEncoder)
