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
