示例#1
0
def test_simplevideo_serializer():
    """
    Test for SimpleVideoSerializer
    """
    video = factories.VideoFactory()
    video_files = [factories.VideoFileFactory(video=video)]
    video_thumbnails = [factories.VideoThumbnailFactory(video=video)]
    expected = {
        "key":
        video.hexkey,
        "created_at":
        DateTimeField().to_representation(video.created_at),
        "title":
        video.title,
        "description":
        video.description,
        "videofile_set":
        serializers.VideoFileSerializer(video_files, many=True).data,
        "videosubtitle_set": [],
        "is_public":
        video.is_public,
        "is_private":
        video.is_private,
        "view_lists": [],
        "collection_view_lists": [],
        "videothumbnail_set":
        serializers.VideoThumbnailSerializer(video_thumbnails, many=True).data,
        "status":
        video.status,
        "collection_key":
        video.collection.hexkey,
        "cloudfront_url":
        "",
    }
    assert serializers.SimpleVideoSerializer(video).data == expected
示例#2
0
def test_video_serializer_validate_title(mocker):
    """
    Test that VideoSerializer raises if title is blank
    """
    mocker.patch("ui.serializers.get_moira_client")
    video = factories.VideoFactory()
    video.title = ""
    serialized_data = serializers.VideoSerializer(video).data
    with pytest.raises(ValidationError) as exc:
        serializers.VideoSerializer(data=serialized_data).is_valid(
            raise_exception=True)
    assert exc.value.detail == {"title": ["This field may not be blank."]}
示例#3
0
def test_video_serializer(youtube, public):
    """
    Test for VideoSerializer
    """
    video = factories.VideoFactory()
    factories.VideoFileFactory(video=video)
    factories.VideoThumbnailFactory(video=video)
    video.is_public = public
    if youtube and public:
        factories.YouTubeVideoFactory(video=video)
    expected = get_expected_result(video)

    expected["youtube_id"] = video.youtube_id if youtube and public else None
    assert serializers.VideoSerializer(video).data == expected
示例#4
0
def test_get_video_analytics(mocker):
    """Test that video analytics data is returned"""
    mock_get_ga_client = mocker.patch("ui.utils.get_google_analytics_client")
    mock_generate_ga_query = mocker.patch(
        "ui.utils.generate_google_analytics_query")
    mock_parse_ga_response = mocker.patch(
        "ui.utils.parse_google_analytics_response")
    video = factories.VideoFactory()
    result = get_video_analytics(video)
    expected_ga_client = mock_get_ga_client.return_value
    expected_batchGet_call = expected_ga_client.reports.return_value.batchGet
    expected_ga_query = mock_generate_ga_query.return_value
    assert expected_batchGet_call.called_once_with(body=expected_ga_query)
    assert mock_parse_ga_response.called_once_with(
        expected_batchGet_call.return_value)
    assert result is mock_parse_ga_response.return_value
示例#5
0
def test_collection_list_serializer():
    """
    Test for CollectionListSerializer
    """
    collection = factories.CollectionFactory()
    _ = [factories.VideoFactory(collection=collection) for _ in range(3)]
    expected = {
        "key": collection.hexkey,
        "created_at": DateTimeField().to_representation(collection.created_at),
        "title": collection.title,
        "description": collection.description,
        "view_lists": [],
        "admin_lists": [],
        "video_count": collection.videos.count(),
        "edx_course_id": collection.edx_course_id,
    }
    assert serializers.CollectionListSerializer(collection).data == expected
示例#6
0
def test_generate_google_analytics_query_success(settings, multiangle):
    """Test that expected query is generated."""
    video = factories.VideoFactory(multiangle=multiangle)
    ga_view_id = "some_view_id"
    settings.GA_VIEW_ID = ga_view_id
    ga_dimension_camera = "some_camera_dimension"
    settings.GA_DIMENSION_CAMERA = ga_dimension_camera
    actual_query = generate_google_analytics_query(video)
    expected_dimensions = [{"name": "ga:eventAction"}]
    if multiangle:
        expected_dimensions.append({"name": "ga:" + ga_dimension_camera})
    expected_query = {
        "reportRequests": [
            {
                "viewId":
                ga_view_id,
                "dateRanges": [{
                    "startDate": "2005-01-01",
                    "endDate": "9999-01-01",
                }],
                "metrics": [{
                    "expression": "ga:totalEvents"
                }],
                "dimensions":
                expected_dimensions,
                "dimensionFilterClauses": [
                    {
                        "filters": [
                            {
                                "dimensionName": "ga:eventLabel",
                                "operator": "EXACT",
                                "expressions": [video.hexkey.capitalize()],
                            },
                        ],
                    },
                ],
            },
        ],
    }
    assert actual_query == expected_query
示例#7
0
def test_collection_serializer():
    """
    Test for CollectionSerializer
    """
    collection = factories.CollectionFactory()
    videos = [factories.VideoFactory(collection=collection) for _ in range(3)]
    expected = {
        "key": collection.hexkey,
        "created_at": DateTimeField().to_representation(collection.created_at),
        "title": collection.title,
        "description": collection.description,
        "videos": serializers.SimpleVideoSerializer(videos, many=True).data,
        "video_count": len(videos),
        "view_lists": [],
        "admin_lists": [],
        "is_logged_in_only": False,
        "is_admin": False,
        "edx_course_id": collection.edx_course_id,
    }
    expected["videos"].sort(key=lambda x: x["key"])
    serialized_data = serializers.CollectionSerializer(collection).data
    serialized_data["videos"].sort(key=lambda x: x["key"])
    assert serialized_data == expected
示例#8
0
def test_video_serializer_with_sharing_url(mocker, has_permission,
                                           allow_share_openedx, hls):
    """
    Test for VideoSerializer for sharing cloudfront url
    """
    mocked_admin_permission = mocker.patch(
        "ui.permissions.has_admin_permission", return_value=has_permission)
    mocked_request = mocker.MagicMock()
    video = factories.VideoFactory()
    factories.VideoFileFactory(video=video, hls=hls)
    factories.VideoThumbnailFactory(video=video)
    video.collection.allow_share_openedx = allow_share_openedx
    video.is_public = True
    expected = get_expected_result(video)
    expected["cloudfront_url"] = (video.videofile_set.filter(
        encoding=EncodingNames.HLS).first().cloudfront_url
                                  if allow_share_openedx and hls
                                  and has_permission else "")
    assert (serializers.VideoSerializer(video,
                                        context={
                                            "request": mocked_request
                                        }).data == expected)
    mocked_admin_permission.assert_called_with(video.collection,
                                               mocked_request)
def video():
    """
    Returns an instance of Video
    """
    return factories.VideoFactory()