def test_collection_for_for_owner():
"""
Tests the for_owner Collection method
"""
owner = UserFactory()
collections = [CollectionFactory(owner=owner) for _ in range(5)]
extra_collection = CollectionFactory()
qset = Collection.for_owner(owner)
assert qset.count() == 5
assert list(qset) == sorted(collections,
key=lambda x: x.created_at,
reverse=True)
assert extra_collection not in qset
def alt_moira_data():
"""
Fixture for tests requiring a moira list, collection, and user
"""
alt_moira_list = MoiraListFactory()
alt_collection = CollectionFactory()
alt_user = factories.UserFactory()
return SimpleNamespace(moira_list=alt_moira_list,
collection=alt_collection,
user=alt_user)
def test_process_dropbox_data_empty_link_list(mocker):
"""
Tests that the process_dropbox_data in case the collection does not exist
"""
mocked_chain = mocker.patch("ui.api.chain")
mocked_stream_to_s3 = mocker.patch("cloudsync.tasks.stream_to_s3")
mocked_transcode_from_s3 = mocker.patch("cloudsync.tasks.transcode_from_s3")
collection = CollectionFactory()
assert (
api.process_dropbox_data(
{
"collection": collection.hexkey,
"files": [],
}
)
== {}
)
assert mocked_chain.call_count == 0
assert mocked_stream_to_s3.s.call_count == 0
assert mocked_transcode_from_s3.si.call_count == 0
def test_video_sources_youtube(youtube_status, is_public, stream_source):
""" Tests that a public video can play from cloudfront if a youtube video does not exist """
public_video = VideoFactory.create(
key="8494dafc-3665-4960-8e00-9790574ec93a",
is_public=is_public,
collection=CollectionFactory(stream_source=stream_source),
)
videofiles = [
VideoFileFactory(video=public_video,
s3_object_key="hd.mp4",
encoding=EncodingNames.HD),
]
if youtube_status is not None:
YouTubeVideoFactory.create(video=public_video, status=youtube_status)
if (youtube_status == YouTubeStatus.PROCESSED and is_public
and stream_source == StreamSource.YOUTUBE):
assert public_video.sources == []
else:
assert public_video.sources == [{
"src": videofiles[0].cloudfront_url,
"label": EncodingNames.HD,
"type": "video/mp4",
}]
def test_process_dropbox_data_happy_path(mocker):
"""
Tests that the process_dropbox_data in case everything is fine
"""
mocked_chain = mocker.patch("ui.api.chain")
mocked_stream_to_s3 = mocker.patch("cloudsync.tasks.stream_to_s3")
mocked_transcode_from_s3 = mocker.patch("cloudsync.tasks.transcode_from_s3")
collection = CollectionFactory()
input_data = {
"collection": collection.hexkey,
"files": [
{"name": name, "link": "http://example.com/{}".format(name)}
for name in (
"foo",
"bar",
)
],
}
results = api.process_dropbox_data(input_data)
assert len(results) == 2
assert mocked_chain.call_count == 2
for key, data in results.items():
qset = models.Video.objects.filter(key=key)
assert qset.exists()
assert qset.count() == 1
video = qset.first()
assert video.collection == collection
assert video.title == data["title"]
assert video.get_s3_key() == data["s3key"]
# checking that the functions in the chain have been called
mocked_stream_to_s3.s.assert_any_call(video.id)
mocked_transcode_from_s3.si.assert_any_call(video.id)
mocked_chain.assert_any_call(
mocked_stream_to_s3.s(video.id), mocked_transcode_from_s3.si(video.id)
)
def test_upload_youtube_videos(mocker, source, max_uploads):
"""
Test that the upload_youtube_videos task calls YouTubeApi.upload_video
& creates a YoutubeVideo object for each public video, up to the max daily limit
"""
settings.YT_UPLOAD_LIMIT = max_uploads
private_videos = VideoFactory.create_batch(2,
is_public=False,
status=VideoStatus.COMPLETE)
VideoFactory.create_batch(
3,
collection=CollectionFactory(stream_source=source),
is_public=True,
status=VideoStatus.COMPLETE,
)
mock_uploader = mocker.patch(
"cloudsync.tasks.YouTubeApi.upload_video",
return_value={
"id":
"".join([random.choice(string.ascii_lowercase) for n in range(8)]),
"status": {
"uploadStatus": "uploaded"
},
},
)
upload_youtube_videos()
assert mock_uploader.call_count == (min(
3, max_uploads) if source != StreamSource.CLOUDFRONT else 0)
for video in Video.objects.filter(
is_public=True).order_by("-created_at")[:settings.YT_UPLOAD_LIMIT]:
if video.collection.stream_source != StreamSource.CLOUDFRONT:
assert YouTubeVideo.objects.filter(video=video).first() is not None
else:
assert YouTubeVideo.objects.filter(video=video).first() is None
for video in private_videos:
assert YouTubeVideo.objects.filter(video=video).first() is None
def test_collection_hexkey():
"""
Tests the collection hexkey property method
"""
collection = CollectionFactory()
assert collection.hexkey == collection.key.hex