def test_get_records_by_parent(app, db, location): """Test get by parent.""" # Create two published records record_v1 = Record.publish(Draft.create({})) db.session.commit() draft = Draft.new_version(record_v1) draft.commit() db.session.commit() record_v2 = Record.publish(draft) db.session.commit() # Get all two versions. parent = record_v2.parent records = Record.get_records_by_parent(parent) # Check that we reuse the parent we passed in. assert id(parent) == id(records[0].parent) == id(records[1].parent)
def test_create_different_key(base_app, db): """Test creation with different key.""" class Record(RecordBase): model_cls = RecordMetadata pid = PIDField('pid.id', provider=RecordIdProviderV2) record = Record.create({}) assert record['pid']['id'] == record.pid.pid_value assert record['pid']['pid_type'] == record.pid.pid_type
def mock_record(app, db, example_record): """An example mock record.""" return Record.create({}, metadata={ 'title': 'Test', 'languages': [{ 'id': 'eng' }] })
def test_record_pid_creation(base_app, db): """Test record creation.""" record = Record.create({}) assert record['id'] == record.pid.pid_value assert record['pid']['pk'] == record.pid.id assert record['pid']['status'] == record.pid.status assert record['pid']['obj_type'] == record.pid.object_type assert record['pid']['pid_type'] == record.pid.pid_type assert record.id == record.pid.object_uuid
def test_record_empty(app, db): """Test record creation.""" # Empty record creation works, and injects a schema. record = Record.create({}) db.session.commit() assert record.schema # JSONSchema validation works. pytest.raises(ValidationError, Record.create, {'metadata': {'title': 1}})
def test_create_record_from_draft(app, db, example_draft): """Test create a record from a draft. This is used e.g. when publishing a new draft as a record. """ record = Record.publish(example_draft) db.session.commit() assert example_draft.pid == record.pid assert example_draft.parent == record.parent
def test_draft_create_new_version(app, db, location): """Test draft creation of the parent record.""" # A published record. record = Record.publish(Draft.create({})) db.session.commit() # Create a draft for a new version (happens in service.new_version()) draft = Draft.new_version(record) draft.commit() db.session.commit() record = Record.get_record(record.id) draft = Draft.get_record(draft.id) assert record.id != draft.id # different uuids assert record.parent.id == draft.parent.id # same parent assert draft.versions.is_latest_draft is True assert draft.versions.is_latest is False assert record.versions.is_latest_draft is False assert record.versions.is_latest is True
def test_draft_parent_state_soft_delete(app, db, location): """Test soft deletion of a draft.""" # Simulate a record being edited. draft = Draft.create({}) record = Record.create({}, parent=draft.parent) db.session.commit() # happens on: # - service.publish() # - service.delete_draft() for a *published* record draft.delete(force=False) db.session.commit() assert ParentState.query.count() == 1 assert ParentRecordMetadata.query.count() == 1 assert RecordMetadata.query.count() == 1 record = Record.get_record(record.id) assert record.versions.next_draft_id is None assert record.versions.latest_id == record.id
def test_draft_parent_state_hard_delete_with_parent(app, db, location): """Test force deletion of a draft.""" # Initial state: A previous reccord version exists, in addition to draft draft = Draft.create({}) record = Record.create({}, parent=draft.parent) db.session.commit() # happens on: # - service.delete_draft for an *unpublished* record draft.delete(force=True) db.session.commit() # Make sure parent/parent state is still there assert ParentState.query.count() == 1 assert ParentRecordMetadata.query.count() == 1 assert RecordMetadata.query.count() == 1 assert DraftMetadata.query.count() == 0 record = Record.get_record(record.id) assert record.versions.next_draft_id is None assert record.versions.latest_id == record.id
def test_session_merge(base_app, db, example_record): """Test the session merge.""" assert inspect(example_record.pid).persistent is True assert inspect(example_record.conceptpid).persistent is True record = Record.get_record(example_record.id) assert inspect(record.pid).persistent is False assert inspect(record.conceptpid).persistent is False Record.pid.session_merge(record) assert inspect(record.pid).persistent is True assert inspect(record.conceptpid).persistent is False
def test_record_pid_dump(base_app, db): """Test record creation.""" # Configured to not dump record = Record.create({}) assert 'is_published' not in record.dumps() # Configure to dump class DumpRecord(Record): is_published = PIDStatusCheckField(status=PIDStatus.REGISTERED, dump=True) record = DumpRecord.create({}) assert record.dumps()['is_published'] is True
def test_record_create_parent_state(app, db, location): """Test draft creation of the parent record.""" draft = Draft.create({}) draft.commit() db.session.commit() record = Record.publish(draft) record.commit() db.session.commit() def assert_state(r): # An initial draft is not published, so latest_id/index is None assert r.versions.latest_id == r.id assert r.versions.latest_index == 1 assert r.versions.next_draft_id is None assert r.versions.index == 1 assert r.versions.is_latest is True assert r.versions.is_latest_draft is True assert r.model.index == 1 assert r.model.parent_id == draft.model.parent_id assert_state(record) assert_state(Record.get_record(record.id))
def test_indexing(mock_record, mock_indexer, mock_search, example_record): # Index document in ES assert mock_indexer.index(mock_record)["result"] == "created" # Retrieve document from ES and load the source data = mock_search(id=mock_record.id) record = Record.loads(data["_source"]) # Getting the language records should work: lang_record = list(record.relations.languages())[0] assert lang_record == example_record # Dereferencing also works record.relations.languages.dereference() deferenced_lang_record = mock_record.metadata['languages'][0] assert sorted(deferenced_lang_record.keys()) == ['id', 'title']
def test_reading_a_pid(base_app, db): """Test reading from dict.""" record = Record({ 'id': '12345-abcde', 'pid': { 'pid_type': 'recid', 'obj_type': 'rec', 'pk': 10, 'status': 'R', } }) assert record.pid is not None assert record['id'] == record.pid.pid_value assert record['pid']['pk'] == record.pid.id assert record['pid']['status'] == record.pid.status assert record['pid']['obj_type'] == record.pid.object_type assert record['pid']['pid_type'] == record.pid.pid_type
def test_create_no_provider(base_app, db): """Test creation without a provider.""" class Record(RecordBase): model_cls = RecordMetadata pid = PIDField() record = Record.create({}) assert record.pid is None record.pid = RecordIdProviderV2.create(object_type='rec', object_uuid=record.id).pid assert record['id'] == record.pid.pid_value assert record['pid']['pk'] == record.pid.id assert record['pid']['status'] == record.pid.status assert record['pid']['obj_type'] == record.pid.object_type assert record['pid']['pid_type'] == record.pid.pid_type assert record.id == record.pid.object_uuid
def test_record_indexing(app, db, es, example_record, indexer): """Test indexing of a record.""" # Index document in ES assert indexer.index(example_record)['result'] == 'created' # Retrieve document from ES data = current_search_client.get('records-record-v1.0.0', id=example_record.id, doc_type='_doc') # Loads the ES data and compare record = Record.loads(data['_source']) assert record == example_record assert record.id == example_record.id assert record.revision_id == example_record.revision_id assert record.created == example_record.created assert record.updated == example_record.updated assert record.expires_at == example_record.expires_at # Check system fields record.metadata == example_record['metadata']
def example_record(app, db): """Example record.""" record = Record.create({}, metadata={'title': 'Test'}) db.session.commit() return record
def test_record_pid_creation(base_app, db): """Test record creation.""" record = Record.create({}) assert record.is_published is True assert record.pid.status == PIDStatus.REGISTERED
def test_instance_attribute_access(base_app, db): """Test record creation.""" record = Record.create({}) assert isinstance(record.index, Index)
def test_record_via_field(app, db): """Record creation via field.""" record = Record.create({}, metadata={'title': 'test'}) assert record.metadata == {'title': 'test'}
def example_record(app, db, input_data): """Example data layer record.""" record = Record.create({}, **input_data) db.session.commit() return record
def example_record(db, example_data): """Example record.""" record = Record.create(example_data, expires_at=datetime(2020, 9, 7, 0, 0)) record.commit() db.session.commit() return record
def test_resolver(base_app, db, example_record): """Test the resolver.""" resolved_record = Record.pid.resolve(example_record.pid.pid_value) loaded_record = Record.get_record(example_record.id) assert resolved_record == loaded_record