def test_video_access_rights_based_on_egroup(mock_datacite, api_app, users,
api_project):
"""Test video access rights based on the e-groups.
Tests that a user can access a deposit based on the e-group permissions.
"""
(project, video_1, video_2) = api_project
cds_depid = video_1['_deposit']['id']
@identity_loaded.connect
def mock_identity_provides(sender, identity):
"""Add additional group to the user."""
identity.provides |= set([RoleNeed('*****@*****.**')])
with api_app.test_client() as client:
prepare_videos_for_publish([video_1, video_2])
video_1['_access'] = {'update': ['*****@*****.**']}
video_1.commit()
db.session.commit()
login_user_via_session(client, email=User.query.get(users[1]).email)
deposit_url = url_for('invenio_deposit_rest.video_item',
pid_value=cds_depid)
publish_url = url_for('invenio_deposit_rest.video_actions',
pid_value=cds_depid,
action='publish')
assert client.get(deposit_url).status_code == 200
assert client.post(publish_url).status_code == 202
def test_video_access_rights_based_on_user_id(mock_datacite, api_app, users,
api_project):
"""Test video access rights based on user ID.
Tests that a user can't access a deposit created by a different user.
"""
(project, video_1, video_2) = api_project
cds_depid = video_1['_deposit']['id']
with api_app.test_client() as client:
prepare_videos_for_publish([video_1, video_2])
deposit_url = url_for('invenio_deposit_rest.video_item',
pid_value=cds_depid)
publish_url = url_for('invenio_deposit_rest.video_actions',
pid_value=cds_depid,
action='publish')
# check anonymous don't have access
assert client.get(deposit_url).status_code == 401
assert client.post(publish_url).status_code == 401
# User is the creator of the deposit, so everything is fine
login_user_via_session(client, email=User.query.get(users[0]).email)
assert client.get(deposit_url).status_code == 200
assert client.post(publish_url).status_code == 202
with api_app.test_client() as client:
login_user_via_session(client, email=User.query.get(users[1]).email)
publish_url = url_for('invenio_deposit_rest.video_actions',
pid_value=cds_depid,
action='publish')
deposit_url = url_for('invenio_deposit_rest.video_item',
pid_value=cds_depid)
# User shouldn't have access to this deposit
assert client.get(deposit_url).status_code == 403
assert client.post(publish_url).status_code == 403
def test_only_videos(db, api_project):
"""Test only videos."""
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
for i, video in enumerate([video_1, video_2]):
video = video.publish()
check_deposit(video, 'CERN-MOVIE-2017-1-{}'.format(i + 1))
def test_project_publish_with_workflow(api_app, users, api_project, es):
"""Test publish a project with a workflow."""
project, video_1, video_2 = api_project
prepare_videos_for_publish([video_1, video_2])
project_depid = project['_deposit']['id']
project_id = str(project.id)
video_1_depid = video_1['_deposit']['id']
video_1_id = str(video_1.id)
video_2_depid = video_2['_deposit']['id']
receiver_id = 'test_project_publish_with_workflow'
workflow_receiver_video_failing(api_app,
db,
video_1,
receiver_id=receiver_id)
headers = [('Content-Type', 'application/json')]
payload = json.dumps(dict(somekey='somevalue'))
with mock.patch('invenio_indexer.tasks.index_record.delay') \
as mock_indexer, \
api_app.test_request_context(headers=headers, data=payload):
event = Event.create(receiver_id=receiver_id)
db.session.add(event)
event.process()
# check video and project are indexed
assert mock_indexer.called is True
ids = get_indexed_records_from_mock(mock_indexer)
assert video_1_id == ids[0]
assert project_id == ids[1]
db.session.commit()
# check tasks status is propagated to video and project
video_1 = deposit_video_resolver(video_1_depid)
expected = {u'add': u'SUCCESS', u'failing': u'FAILURE'}
assert video_1['_cds']['state'] == expected
assert video_1.project['_cds']['state'] == expected
events = get_deposit_events(deposit_id=video_1_depid)
assert len(events) == 1
def check(project_status, video_1_status, video_2_status):
project = deposit_project_resolver(project_depid)
video_1 = deposit_video_resolver(video_1_depid)
video_2 = deposit_video_resolver(video_2_depid)
assert project.status == project_status
assert video_1.status == video_1_status
assert video_2.status == video_2_status
check('draft', 'draft', 'draft')
login_user(User.query.get(users[0]))
video_2 = deposit_video_resolver(video_2_depid)
video_2.publish()
check('draft', 'draft', 'published')
project = deposit_project_resolver(project_depid)
project.publish()
check('published', 'published', 'published')
def test_sync_records_with_deposits(app, db, location, users,
project_deposit_metadata,
video_deposit_metadata):
"""Test sync records with deposits task."""
# create a project
project = Project.create(project_deposit_metadata)
project_deposit_metadata['report_number'] = ['123']
# create new video
video_deposit_metadata['_project_id'] = project['_deposit']['id']
deposit = Video.create(video_deposit_metadata)
depid = deposit['_deposit']['id']
# insert objects inside the deposit
ObjectVersion.create(deposit.files.bucket,
"obj_1").set_location("mylocation1", 1, "mychecksum1")
ObjectVersion.create(deposit.files.bucket,
"obj_2").set_location("mylocation2", 1, "mychecksum2")
ObjectVersion.create(deposit.files.bucket,
"obj_3").set_location("mylocation3", 1, "mychecksum3")
obj_4 = ObjectVersion.create(deposit.files.bucket,
"obj_4").set_location("mylocation4", 1,
"mychecksum4")
# publish
login_user(User.query.get(users[0]))
prepare_videos_for_publish([deposit])
deposit = deposit.publish()
_, record = deposit.fetch_published()
assert deposit.is_published() is True
# add a new object
ObjectVersion.create(deposit.files.bucket,
"obj_new").set_location("mylocation_new", 1,
"mychecksum")
# modify obj_1
ObjectVersion.create(deposit.files.bucket,
"obj_new").set_location("mylocation2.1", 1,
"mychecksum2.1")
# delete obj_3
ObjectVersion.delete(deposit.files.bucket, "obj_3")
# remove obj_4
obj_4.remove()
# check video and record
files = ['obj_1', 'obj_2', 'obj_3', 'obj_4']
edited_files = ['obj_1', 'obj_2', 'obj_3', 'obj_new']
check_deposit_record_files(deposit, edited_files, record, files)
# try to sync deposit and record
sync_records_with_deposit_files.s(deposit_id=depid).apply_async()
# get deposit and record
deposit = deposit_video_resolver(depid)
_, record = deposit.fetch_published()
assert deposit.is_published() is True
# check that record and deposit are sync
re_edited_files = edited_files + ['obj_4']
check_deposit_record_files(deposit, edited_files, record, re_edited_files)
def test_only_videos(db, api_project, users):
"""Test only videos."""
login_user(User.query.get(users[0]))
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
for i, video in enumerate([video_1, video_2]):
video = video.publish()
check_deposit(video, 'CERN-MOVIE-2017-1-{}'.format(i + 1))
def test_project_and_videos(db, api_project):
"""Test project and video."""
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
project = project.publish()
check_deposit(project, 'CERN-MOVIE-2017-1')
for i, video in enumerate(record_video_resolver_sorted(project.video_ids)):
check_deposit(video, 'CERN-MOVIE-2017-1-{}'.format(i + 1))
def test_search_excluded_fields(api_app, users, api_project,
json_headers, location,
project_deposit_metadata):
"""Test search excluded fields."""
# publish a project with "contributors" field
(project, video_1, video_2) = api_project
with api_app.test_request_context():
prepare_videos_for_publish([video_1, video_2])
video_1['contributors'] = [
{
"affiliations": [
"Universita degli Studi di Udine (IT)"
],
"email": "*****@*****.**",
"ids": [
{
"source": "cern",
"value": "123456"
},
{
"source": "cds",
"value": "67890"
}
],
"name": "Fuu, Bar",
"role": "Director"
}
],
project = project.publish()
video = project.videos[0]
indexer = RecordIndexer()
indexer.index(video)
sleep(2)
with api_app.test_client() as client:
# check record is indexed
res = client.get(url_for('invenio_records_rest.recid_list',
headers=json_headers))
assert res.status_code == 200
data = json.loads(res.data.decode('utf-8'))
assert len(data['hits']['hits']) == 1
# check record is not searchable for contributors role
res = client.get(url_for('invenio_records_rest.recid_list',
q='Director', headers=json_headers))
assert res.status_code == 200
data = json.loads(res.data.decode('utf-8'))
assert len(data['hits']['hits']) == 0
# check record is not searchable for contributors id
res = client.get(url_for('invenio_records_rest.recid_list',
q='67890', headers=json_headers))
assert res.status_code == 200
data = json.loads(res.data.decode('utf-8'))
assert len(data['hits']['hits']) == 0
def test_project_and_videos(db, api_project, users, current_year):
"""Test project and video."""
login_user(User.query.get(users[0]))
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
project = project.publish()
check_deposit(project, 'CERN-MOVIE-{0}-1'.format(current_year))
for i, video in enumerate(record_video_resolver_sorted(project.video_ids)):
check_deposit(video,
'CERN-MOVIE-{0}-1-{1}'.format(current_year, i + 1))
def test_record_video_links(datacite_mock, api_app, es, api_project, users,
json_headers):
"""Test record video links."""
(project, video_1, video_2) = api_project
user = User.query.filter_by(id=users[0]).first()
prepare_videos_for_publish([video_1, video_2])
vid = video_1['_deposit']['id']
pid = project['_deposit']['id']
with api_app.test_client() as client:
login_user_via_session(client, user)
# publish video
url = url_for('invenio_deposit_rest.video_actions',
pid_value=vid,
action='publish')
assert client.post(url).status_code == 202
rec_pid, rec_video = deposit_video_resolver(vid).fetch_published()
# get a record video (with no published project)
url = url_for('invenio_records_rest.recid_item',
pid_value=rec_pid.pid_value,
_external=True)
res = client.get(url, headers=json_headers)
assert res.status_code == 200
# check video record
data = json.loads(res.data.decode('utf-8'))
assert data['links'] == {'self': url}
# publish the project
url = url_for('invenio_deposit_rest.project_actions',
pid_value=pid,
action='publish')
assert client.post(url).status_code == 202
rec_pid_proj, rec_proj = video_1.project.fetch_published()
# get a record video (with published project)
url = url_for('invenio_records_rest.recid_item',
pid_value=rec_pid.pid_value,
_external=True)
res = client.get(url, headers=json_headers)
assert res.status_code == 200
# check video record
data = json.loads(res.data.decode('utf-8'))
url_api_prj = 'http://localhost/record/3'
url_prj = 'http://localhost/record/3'
url_prj_edit = 'http://localhost/deposit/project/{0}'.format(pid)
assert data['links'] == {
'self': url,
'project': url_api_prj,
'project_html': url_prj,
'project_edit': url_prj_edit,
}
def test_deposit_vtt_tags(api_app, db, api_project, users):
"""Test VTT tag generation."""
project, video_1, video_2 = api_project
video_1_depid = video_1['_deposit']['id']
# insert a master file inside the video
add_master_to_video(
video_deposit=video_1,
filename='test.mp4',
stream=BytesIO(b'1234'), video_duration="15"
)
# try to insert a new vtt object
obj = ObjectVersion.create(
video_1._bucket, key="test_fr.vtt",
stream=BytesIO(b'hello'))
# publish the video
prepare_videos_for_publish([video_1])
video_1 = deposit_video_resolver(video_1_depid)
login_user(User.query.get(users[0]))
video_1 = video_1.publish()
# check tags
check_object_tags(obj, video_1, content_type='vtt', media_type='subtitle',
context_type='subtitle', language='fr')
# edit the video
video_1 = video_1.edit()
# try to delete the old vtt file and substitute with a new one
video_1 = deposit_video_resolver(video_1_depid)
ObjectVersion.delete(bucket=video_1._bucket, key=obj.key)
obj2 = ObjectVersion.create(
video_1._bucket, key="test_en.vtt", stream=BytesIO(b'hello'))
# publish again the video
video_1 = video_1.publish()
# check tags
check_object_tags(obj2, video_1, content_type='vtt', media_type='subtitle',
context_type='subtitle', language='en')
# edit a re-published video
video_1 = video_1.edit()
# add a new vtt file
obj3 = ObjectVersion.create(
video_1._bucket, key="test_it.vtt", stream=BytesIO(b'hello'))
# publish again the video
video_1 = video_1.publish()
# check tags
check_object_tags(obj3, video_1, content_type='vtt', media_type='subtitle',
context_type='subtitle', language='it')
def test_video_publish_registering_the_datacite_not_local(
datacite_mock, api_app, users, location, cds_jsonresolver,
json_headers, json_partial_project_headers, json_partial_video_headers,
deposit_metadata, video_deposit_metadata, project_deposit_metadata,
keyword_1, keyword_2):
"""Test video publish registering the datacite not local."""
# test: enable datacite registration
api_app.config['DEPOSIT_DATACITE_MINTING_ENABLED'] = True
with api_app.test_client() as client:
login_user_via_session(client, email=User.query.get(users[0]).email)
project_deposit_metadata['keywords'] = [copy.deepcopy(keyword_2)]
# [[ CREATE NEW PROJECT ]]
project_dict = _create_new_project(client,
json_partial_project_headers,
project_deposit_metadata)
assert project_dict['metadata']['keywords'][0] == keyword_2
project_depid = project_dict['metadata']['_deposit']['id']
project = deposit_project_resolver(project_depid)
assert project['keywords'] == [{
'$ref': keyword_2.ref,
'name': keyword_2['name'],
}]
# [[ ADD A NEW VIDEO_1 ]]
video_metadata = copy.deepcopy(video_deposit_metadata)
video_metadata['keywords'] = [copy.deepcopy(keyword_1)]
video_metadata.update(
_project_id=project_dict['metadata']['_deposit']['id'])
res = client.post(url_for('invenio_deposit_rest.video_list'),
data=json.dumps(video_metadata),
headers=json_partial_video_headers)
assert res.status_code == 201
video_1_dict = json.loads(res.data.decode('utf-8'))
assert video_1_dict['metadata']['keywords'][0] == keyword_1
video_1_depid = video_1_dict['metadata']['_deposit']['id']
video_1 = deposit_video_resolver(video_1_depid)
assert video_1['keywords'] == [{
'$ref': keyword_1.ref,
'name': keyword_1['name'],
}]
video_1['doi'] = '10.1123/doi'
prepare_videos_for_publish([video_1])
# [[ PUBLISH VIDEO ]]
video_1.publish()
datacite_register.s(pid_value='123',
record_uuid=str(video_1.id)).apply()
assert datacite_mock.called is False
def test_video_publish_with_no_category(api_project):
"""Test video publish if category is not set."""
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
# test: no category in project
del project['category']
assert 'type' in project
project.commit()
db.session.commit()
with pytest.raises(ValidationError):
video_1.publish()
def api_project_published(api_app, api_project):
"""New published project with videos."""
(project, video_1, video_2) = api_project
with api_app.test_request_context():
prepare_videos_for_publish([video_1, video_2])
new_project = project.publish()
new_videos = [record_resolver.resolve(id_)[1]
for id_ in new_project.video_ids]
assert len(new_videos) == 2
return (new_project,
Video.get_record(new_videos[0].id),
Video.get_record(new_videos[1].id))
def test_video_publish_with_category_and_type(api_project):
"""Test video publish with category and type."""
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
video_1_depid = video_1['_deposit']['id']
# test with category + type
assert 'type' in project
assert 'category' in project
project.commit()
db.session.commit()
video_1 = deposit_video_resolver(video_1_depid)
video_1.publish()
assert video_1['_deposit']['status'] == 'published'
def test_video_publish_with_no_type(api_project):
"""Test video publish with no type."""
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
video_1_depid = video_1['_deposit']['id']
# test: no type in project
del project['type']
assert 'category' in project
project.commit()
db.session.commit()
video_1 = deposit_video_resolver(video_1_depid)
with pytest.raises(ValidationError):
video_1.publish()
def test_video_then_project(db, api_project):
"""Test video and then project."""
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
video_1 = video_1.publish()
check_deposit(video_1, 'CERN-MOVIE-2017-1-1')
project = video_1.project
project = project.publish()
check_deposit(project, 'CERN-MOVIE-2017-1')
video_2 = record_video_resolver_sorted(project.video_ids)[1]
check_deposit(video_2, 'CERN-MOVIE-2017-1-2')
def test_inheritance(api_app, api_project):
"""Test that videos inherit the proper fields from parent project."""
(project, video, _) = api_project
assert 'category' in project
assert 'type' in project
# Publish the video
prepare_videos_for_publish([video])
video = video.publish()
assert 'category' in video
assert 'type' in video
assert video['category'] == project['category']
assert video['type'] == project['type']
def _upload_video_and_publish(video):
bucket_id = video['_buckets']['deposit']
random_file_content = 'fake video file ' + _random_string()
random_bytes = random_file_content.encode('utf-8')
video_file = ObjectVersion.create(bucket=bucket_id,
key='master.mp4',
stream=BytesIO(random_bytes))
ObjectVersionTag.create(video_file, 'context_type', 'master')
prepare_videos_for_publish([video])
published_video = video.publish()
(_, record_published_video) = published_video.fetch_published()
return published_video, record_published_video
def test_video_then_project(db, api_project, users, current_year):
"""Test video and then project."""
login_user(User.query.get(users[0]))
(project, video_1, video_2) = api_project
prepare_videos_for_publish([video_1, video_2])
video_1 = video_1.publish()
check_deposit(video_1, 'CERN-MOVIE-{0}-1-1'.format(current_year))
project = video_1.project
project = project.publish()
check_deposit(project, 'CERN-MOVIE-{0}-1'.format(current_year))
video_2 = record_video_resolver_sorted(project.video_ids)[1]
check_deposit(video_2, 'CERN-MOVIE-{0}-1-2'.format(current_year))
def test_project_access_rights_based_admin(api_app, users, api_project):
"""Test project access rights based on the admin."""
(project, video_1, video_2) = api_project
cds_depid = project['_deposit']['id']
with api_app.test_client() as client:
prepare_videos_for_publish([video_1, video_2])
login_user_via_session(client,
email=User.query.get(users[2]).email)
deposit_url = url_for('invenio_deposit_rest.project_item',
pid_value=cds_depid)
publish_url = url_for('invenio_deposit_rest.project_actions',
pid_value=cds_depid, action='publish')
assert client.get(deposit_url).status_code == 200
assert client.post(publish_url).status_code == 202
def test_deposit_poster_tags(api_app, db, api_project, users):
"""Test poster tag generation."""
project, video_1, video_2 = api_project
video_1_depid = video_1['_deposit']['id']
master_video_filename = 'test.mp4'
poster_filename = 'poster.jpg'
poster_filename2 = 'poster.png'
# insert a master file inside the video
add_master_to_video(video_deposit=video_1,
filename=master_video_filename,
stream=BytesIO(b'1234'),
video_duration='15')
# try to insert a new vtt object
obj = ObjectVersion.create(video_1._bucket,
key=poster_filename,
stream=BytesIO(b'hello'))
# publish the video
prepare_videos_for_publish([video_1])
video_1 = deposit_video_resolver(video_1_depid)
login_user(User.query.get(users[0]))
video_1 = video_1.publish()
# check tags
check_object_tags(obj,
video_1,
content_type='jpg',
context_type='poster',
media_type='image')
# edit the video
video_1 = video_1.edit()
# try to delete the old poster frame and substitute with a new one
video_1 = deposit_video_resolver(video_1_depid)
ObjectVersion.delete(bucket=video_1._bucket, key=obj.key)
obj2 = ObjectVersion.create(video_1._bucket,
key=poster_filename2,
stream=BytesIO(b'hello'))
# publish again the video
video_1 = video_1.publish()
# check tags
check_object_tags(obj2,
video_1,
content_type='png',
context_type='poster',
media_type='image')
def test_video_publish_registering_the_datacite(
datacite_mock, api_app, users, location, cds_jsonresolver,
json_headers, json_partial_project_headers, json_partial_video_headers,
deposit_metadata, video_deposit_metadata, project_deposit_metadata):
"""Test video publish registering the datacite."""
# test: enable datacite registration
api_app.config['DEPOSIT_DATACITE_MINTING_ENABLED'] = True
with api_app.test_client() as client:
login_user_via_session(client, email=User.query.get(users[0]).email)
# [[ CREATE NEW PROJECT ]]
project_dict = _create_new_project(client,
json_partial_project_headers,
project_deposit_metadata)
# [[ ADD A NEW EMPTY VIDEO_1 ]]
video_1_dict = _add_video_info_to_project(client,
json_partial_video_headers,
project_dict,
video_deposit_metadata)
video_1_depid = video_1_dict['metadata']['_deposit']['id']
video_1 = deposit_video_resolver(video_1_depid)
prepare_videos_for_publish([video_1])
# [[ PUBLISH VIDEO ]]
video_1.publish()
# [[ REGISTER DATACITE ]]
datacite_register_after_publish(sender=api_app,
action='publish',
deposit=video_1)
assert datacite_mock.called is True
assert datacite_mock().metadata_post.call_count == 1
datacite_mock().doi_post.assert_called_once_with(
'10.0000/cds.1', 'https://cds.cern.ch/record/1')
# [[ UPDATE DATACITE ]]
datacite_register_after_publish(sender=api_app,
action='publish',
deposit=video_1)
assert datacite_mock.called is True
assert datacite_mock().metadata_post.call_count == 2
datacite_mock().doi_post.assert_called_with(
'10.0000/cds.1', 'https://cds.cern.ch/record/1')
def test_publish_all_videos(api_app, api_project):
"""Test video publish."""
(project, video_1, video_2) = api_project
# check video1 is not published
assert video_1['_deposit']['status'] == 'draft'
assert video_2['_deposit']['status'] == 'draft'
assert project['_deposit']['status'] == 'draft'
# publish project
prepare_videos_for_publish([video_1, video_2])
new_project = project.publish()
# check project and all video are published
assert new_project['_deposit']['status'] == 'published'
videos = [record_video_resolver(id_) for id_ in new_project.video_ids]
assert len(videos) == 2
for video in videos:
assert video['_deposit']['status'] == 'published'
def test_legacy_embed(previewer_app, db, api_project, video, users):
"""Test backwards-compatibility with legacy embed URL for videos."""
project, video_1, _ = api_project
filename = 'test.mp4'
bucket_id = video_1['_buckets']['deposit']
obj = ObjectVersion.create(bucket=bucket_id, key=filename,
stream=open(video, 'rb'))
ObjectVersionTag.create(obj, 'context_type', 'master')
ObjectVersionTag.create(obj, 'preview', True)
login_user(User.query.get(users[0]))
prepare_videos_for_publish([video_1])
video_1 = video_1.publish()
with previewer_app.test_client() as client:
res = client.get('/video/{0}'.format(video_1.report_number))
assert res.location.endswith(url_for(
'invenio_records_ui.recid_embed_default',
pid_value=video_1['recid'],
))
def test_deposit_smil_tag_generation(api_app, db, api_project, users):
"""Test AVCWorkflow receiver."""
def check_smil(video):
_, record = video.fetch_published()
master = CDSVideosFilesIterator.get_master_video_file(record)
playlist = master['playlist']
assert playlist[0]['key'] == '{}.smil'. \
format(record['report_number'][0])
assert playlist[0]['content_type'] == 'smil'
assert playlist[0]['context_type'] == 'playlist'
assert playlist[0]['media_type'] == 'text'
assert playlist[0]['tags']['master'] == master['version_id']
# check bucket dump is done correctly
master_video = CDSVideosFilesIterator.get_master_video_file(video)
assert master_video['version_id'] != master['version_id']
project, video_1, video_2 = api_project
video_1_depid = video_1['_deposit']['id']
# insert a master file inside the video
add_master_to_video(video_deposit=video_1,
filename='test.mp4',
stream=BytesIO(b'1234'),
video_duration="15s")
# publish the video
prepare_videos_for_publish([video_1])
video_1 = deposit_video_resolver(video_1_depid)
login_user(User.query.get(users[0]))
video_1 = video_1.publish()
# check smil
check_smil(video_1)
# edit the video
video_1 = video_1.edit()
# publish again the video
video_1 = video_1.publish()
# check smil
check_smil(video_1)
def test_video_name_after_publish(api_app, db, api_project, users):
project, video_1, video_2 = api_project
video_1_depid = video_1['_deposit']['id']
master_video_filename = 'test.mp4'
# insert a master file inside the video
add_master_to_video(video_deposit=video_1,
filename=master_video_filename,
stream=BytesIO(b'1234'),
video_duration='15')
# publish the video
prepare_videos_for_publish([video_1])
video_1 = deposit_video_resolver(video_1_depid)
login_user(User.query.get(users[0]))
video_1 = video_1.publish()
_, record = video_1.fetch_published()
master = CDSVideosFilesIterator.get_master_video_file(record)
assert master['key'] == '{}.mp4'.format(record['report_number'][0])
def test_project_partial_validation(api_app, db, api_cds_jsonresolver,
deposit_metadata, location,
video_deposit_metadata, users):
"""Test project create/publish with partial validation/validation."""
video_1 = deepcopy(video_deposit_metadata)
# create a deposit without a required field
if 'category' in deposit_metadata:
del deposit_metadata['category']
with api_app.test_request_context():
login_user(User.query.get(users[0]))
project = Project.create(deposit_metadata)
video_1['_project_id'] = project['_deposit']['id']
video_1 = Video.create(video_1)
prepare_videos_for_publish([video_1])
video_1.commit()
id_ = project.id
db.session.expire_all()
project = Project.get_record(id_)
assert project is not None
# if publish, then generate an validation error
with pytest.raises(ValidationError):
project.publish()
# patch project
patch = [{
'op': 'add',
'path': '/category',
'value': 'bar',
}]
id_ = project.id
db.session.expire_all()
project = Project.get_record(id_)
project.patch(patch).commit()
# update project
copy = deepcopy(project)
copy['category'] = 'qwerty'
id_ = project.id
db.session.expire_all()
project = Project.get_record(id_)
project.update(copy)
# assert not raise a validation exception
project.commit()
def test_publish_one_video(api_app, api_project):
"""Test video publish."""
(project, video_1, video_2) = api_project
# check video1 is not published
assert video_1['_deposit']['status'] == 'draft'
assert video_2['_deposit']['status'] == 'draft'
assert project['_deposit']['status'] == 'draft'
# [publish project]
prepare_videos_for_publish([video_1, video_2])
# publish one video
video_1 = video_1.publish()
project = video_1.project
# publish the project (with one video still not publish)
project = project.publish()
# check project and all video are published
assert project['_deposit']['status'] == 'published'
videos = [record_video_resolver(id_) for id_ in project.video_ids]
assert len(videos) == 2
for video in videos:
assert video['_deposit']['status'] == 'published'
def test_video_publish_registering_the_datacite_if_fail(
datacite_mock, api_app, users, location, cds_jsonresolver,
json_headers, json_partial_project_headers, json_partial_video_headers,
deposit_metadata, video_deposit_metadata, project_deposit_metadata):
"""Test video publish registering the datacite."""
# test: enable datacite registration
api_app.config['DEPOSIT_DATACITE_MINTING_ENABLED'] = True
with api_app.test_client() as client:
login_user_via_session(client, email=User.query.get(users[0]).email)
# [[ CREATE NEW PROJECT ]]
project_dict = _create_new_project(client,
json_partial_project_headers,
project_deposit_metadata)
# [[ ADD A NEW EMPTY VIDEO_1 ]]
video_1_dict = _add_video_info_to_project(client,
json_partial_video_headers,
project_dict,
video_deposit_metadata)
video_1_depid = video_1_dict['metadata']['_deposit']['id']
video_1 = deposit_video_resolver(video_1_depid)
prepare_videos_for_publish([video_1])
# [[ PUBLISH VIDEO ]]
video_1.publish()
db.session.commit()
with mock.patch('invenio_records.api.Record.get_record',
side_effect=[Exception, video_1],
return_value=video_1):
with pytest.raises(Retry):
datacite_register.s(pid_value='1',
record_uuid=str(video_1.id)).apply()
assert datacite_mock.called is True
assert datacite_mock().metadata_post.call_count == 1
datacite_mock().doi_post.assert_called_once_with(
'10.0000/cds.1', 'https://cds.cern.ch/record/1')
assert datacite_mock.call_count == 3
