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