def test_derive_right(mock_plugin_for_deriving_rights, mock_coalaip,
right_data, alice_user, data_format,
use_data_format_enum, mock_right_create_id):
derive_right_kwargs = {}
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format_arg = get_data_format_enum_member(data_format)
else:
data_format_arg = data_format
derive_right_kwargs['data_format'] = data_format_arg
# Create the Right and test it was persisted
right = mock_coalaip.derive_right(right_data,
current_holder=alice_user,
**derive_right_kwargs)
assert right.persist_id == mock_right_create_id
# Test the correct data format was persisted
if data_format == 'json':
right_persisted_data = right.to_json()
elif data_format == 'ipld':
raise NotImplementedError('IPLD is not implemented yet')
else:
right_persisted_data = right.to_jsonld()
# Check we called plugin.save() with the right format
mock_plugin_for_deriving_rights.save.assert_called_once_with(
right_persisted_data, user=alice_user)
def test_derive_right(mock_plugin_for_deriving_rights, mock_coalaip,
right_data, alice_user, data_format,
use_data_format_enum, mock_right_create_id):
derive_right_kwargs = {}
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format_arg = get_data_format_enum_member(data_format)
else:
data_format_arg = data_format
derive_right_kwargs['data_format'] = data_format_arg
# Create the Right and test it was persisted
right = mock_coalaip.derive_right(right_data, current_holder=alice_user,
**derive_right_kwargs)
assert right.persist_id == mock_right_create_id
# Test the correct data format was persisted
if data_format == 'json':
right_persisted_data = right.to_json()
elif data_format == 'ipld':
raise NotImplementedError('IPLD is not implemented yet')
else:
right_persisted_data = right.to_jsonld()
# Check we called plugin.save() with the right format
mock_plugin_for_deriving_rights.save.assert_called_once_with(
right_persisted_data, user=alice_user)
def test_entity_create(mock_plugin, alice_user, data_format,
use_data_format_enum, entity_name,
mock_entity_create_id, request):
entity = request.getfixturevalue(entity_name)
entity_cls_name = CLS_FOR_ENTITY[entity_name]
mock_plugin.save.return_value = mock_entity_create_id
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format_arg = get_data_format_enum_member(data_format)
else:
data_format_arg = data_format
persist_id = entity.create(alice_user, data_format_arg)
else:
persist_id = entity.create(alice_user)
assert mock_plugin.save.call_count == 1
assert persist_id == mock_entity_create_id
assert persist_id == entity.persist_id
if not data_format or data_format == 'jsonld':
data = request.getfixturevalue(JSONLD_NAME_FOR_ENTITY_CLS[entity_cls_name])
elif data_format == 'json':
data = request.getfixturevalue(JSON_NAME_FOR_ENTITY_CLS[entity_cls_name])
mock_plugin.save.assert_called_with(data, user=alice_user)
def test_entity_ignores_context_from_non_ld_data(
mock_plugin, data_format, use_data_format_enum, entity_cls_name,
mock_entity_context, request):
entity_cls = get_entity_cls(entity_cls_name)
data = request.getfixturevalue(JSONLD_NAME_FOR_ENTITY_CLS[entity_cls_name])
data['@context'] = mock_entity_context
kwargs = {}
if data_format:
if data_format == 'json':
data = request.getfixturevalue(JSON_NAME_FOR_ENTITY_CLS[entity_cls_name])
data['context'] = mock_entity_context
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format = get_data_format_enum_member(data_format)
kwargs['data_format'] = data_format
kwargs['data'] = data
entity = entity_cls.from_data(plugin=mock_plugin, **kwargs)
# Test entity ignores @context since the data wasn't in JSON-LD
assert entity.model.ld_context != mock_entity_context
assert entity.to_jsonld()['@context'] != mock_entity_context
def test_non_strict_type_entity_keeps_diff_type_from_data(
mock_plugin, data_format, use_data_format_enum, entity_cls_name,
mock_entity_type, request):
entity_cls = get_entity_cls(entity_cls_name)
kwargs = {}
if data_format:
if data_format == 'json':
data = request.getfixturevalue(JSON_NAME_FOR_ENTITY_CLS[entity_cls_name])
data['type'] = mock_entity_type
elif data_format == 'jsonld':
data = request.getfixturevalue(JSONLD_NAME_FOR_ENTITY_CLS[entity_cls_name])
data['@type'] = mock_entity_type
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format = get_data_format_enum_member(data_format)
kwargs['data_format'] = data_format
kwargs['data'] = data
entity = entity_cls.from_data(plugin=mock_plugin, **kwargs)
# Test entity uses specified @type
assert entity.model.ld_type == mock_entity_type
assert entity.to_jsonld()['@type'] == mock_entity_type
def test_entity_init_from_data(mock_plugin, data_format, use_data_format_enum,
entity_cls_name, request):
entity_cls = get_entity_cls(entity_cls_name)
data = request.getfixturevalue(DATA_NAME_FOR_ENTITY_CLS[entity_cls_name])
json = request.getfixturevalue(JSON_NAME_FOR_ENTITY_CLS[entity_cls_name])
jsonld = request.getfixturevalue(JSONLD_NAME_FOR_ENTITY_CLS[entity_cls_name])
kwargs = {}
if data_format is None:
kwargs['data'] = data
else:
if data_format == 'json':
kwargs['data'] = json
elif data_format == 'jsonld':
kwargs['data'] = jsonld
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format = get_data_format_enum_member(data_format)
kwargs['data_format'] = data_format
entity = entity_cls.from_data(plugin=mock_plugin, **kwargs)
assert entity.persist_id is None
assert entity.to_json() == json
assert entity.to_jsonld() == jsonld
def test_entity_keeps_context_from_ld_data(mock_plugin, use_data_format_enum,
entity_cls_name,
mock_entity_context, request):
entity_cls = get_entity_cls(entity_cls_name)
data = request.getfixturevalue(JSONLD_NAME_FOR_ENTITY_CLS[entity_cls_name])
data['@context'] = mock_entity_context
data_format = 'jsonld'
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format = get_data_format_enum_member(data_format)
entity = entity_cls.from_data(data, data_format=data_format,
plugin=mock_plugin)
# Test entity keeps @context if the data's in JSON-LD
assert entity.model.ld_context == mock_entity_context
assert entity.to_jsonld()['@context'] == mock_entity_context
def test_transfer_right(mock_plugin, mock_coalaip, alice_user, bob_user,
data_format, use_data_format_enum,
rights_assignment_data, persisted_jsonld_derived_right,
mock_rights_assignment_transfer_id):
mock_plugin.transfer.return_value = mock_rights_assignment_transfer_id
transfer_right_kwargs = {}
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format_arg = get_data_format_enum_member(data_format)
else:
data_format_arg = data_format
transfer_right_kwargs['rights_assignment_format'] = data_format_arg
# Transfer the Right and test the resulting RightsAssignment is correct
rights_assignment = mock_coalaip.transfer_right(
persisted_jsonld_derived_right,
rights_assignment_data,
current_holder=alice_user,
to=bob_user,
**transfer_right_kwargs)
assert rights_assignment.persist_id == mock_rights_assignment_transfer_id
assert rights_assignment.data == rights_assignment_data
# Test the correct data format was used in the transfer
if data_format == 'json':
rights_assignment_persisted_data = rights_assignment.to_json()
elif data_format == 'ipld':
raise NotImplementedError('IPLD is not implemented yet')
else:
rights_assignment_persisted_data = rights_assignment.to_jsonld()
# Check we called plugin.transfer() with the right format
mock_plugin.transfer.assert_called_once_with(
persisted_jsonld_derived_right.persist_id,
rights_assignment_persisted_data,
from_user=alice_user,
to_user=bob_user)
def test_strict_type_entity_raises_on_diff_type_from_data(
mock_plugin, data_format, use_data_format_enum, entity_cls_name,
mock_entity_type, request):
from coalaip.exceptions import ModelError
entity_cls = get_entity_cls(entity_cls_name)
kwargs = {}
if data_format:
if data_format == 'json':
data = request.getfixturevalue(JSON_NAME_FOR_ENTITY_CLS[entity_cls_name])
data['type'] = mock_entity_type
elif data_format == 'jsonld':
data = request.getfixturevalue(JSONLD_NAME_FOR_ENTITY_CLS[entity_cls_name])
data['@type'] = mock_entity_type
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format = get_data_format_enum_member(data_format)
kwargs['data_format'] = data_format
kwargs['data'] = data
with raises(ModelError):
entity_cls.from_data(plugin=mock_plugin, **kwargs)
def test_right_transferrable(mock_plugin, alice_user, bob_user,
rights_assignment_data, right_entity_name,
mock_create_id_name, data_format,
rights_assignment_saved_data_name,
use_data_format_enum,
mock_rights_assignment_transfer_id, request):
right_entity = request.getfixturevalue(right_entity_name)
mock_create_id = request.getfixturevalue(mock_create_id_name)
# Save the Copyright
mock_plugin.save.return_value = mock_create_id
right_entity.create(user=alice_user)
# Set up the arguments
mock_plugin.transfer.return_value = mock_rights_assignment_transfer_id
transfer_kwargs = {
'from_user': alice_user,
'to_user': bob_user
}
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format = get_data_format_enum_member(data_format)
transfer_kwargs['rights_assignment_format'] = data_format
# Test the transfer
rights_assignment = right_entity.transfer(rights_assignment_data,
**transfer_kwargs)
assert rights_assignment.persist_id == mock_rights_assignment_transfer_id
assert rights_assignment.data == rights_assignment_data
rights_assignment_saved_data = request.getfixturevalue(
rights_assignment_saved_data_name)
mock_plugin.transfer.assert_called_with(mock_create_id,
rights_assignment_saved_data,
from_user=alice_user,
to_user=bob_user)
def test_transfer_right(mock_plugin, mock_coalaip, alice_user, bob_user,
data_format, use_data_format_enum,
rights_assignment_data, persisted_jsonld_derived_right,
mock_rights_assignment_transfer_id):
mock_plugin.transfer.return_value = mock_rights_assignment_transfer_id
transfer_right_kwargs = {}
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format_arg = get_data_format_enum_member(data_format)
else:
data_format_arg = data_format
transfer_right_kwargs['rights_assignment_format'] = data_format_arg
# Transfer the Right and test the resulting RightsAssignment is correct
rights_assignment = mock_coalaip.transfer_right(
persisted_jsonld_derived_right, rights_assignment_data,
current_holder=alice_user, to=bob_user, **transfer_right_kwargs)
assert rights_assignment.persist_id == mock_rights_assignment_transfer_id
assert rights_assignment.data == rights_assignment_data
# Test the correct data format was used in the transfer
if data_format == 'json':
rights_assignment_persisted_data = rights_assignment.to_json()
elif data_format == 'ipld':
raise NotImplementedError('IPLD is not implemented yet')
else:
rights_assignment_persisted_data = rights_assignment.to_jsonld()
# Check we called plugin.transfer() with the right format
mock_plugin.transfer.assert_called_once_with(
persisted_jsonld_derived_right.persist_id,
rights_assignment_persisted_data,
from_user=alice_user,
to_user=bob_user)
def test_register_manifestation(mock_plugin, mock_coalaip, manifestation_data,
alice_user, data_format, use_data_format_enum,
mock_work_create_id,
mock_manifestation_create_id,
mock_copyright_create_id):
from tests.utils import create_entity_id_setter
# Remove the 'manifestationOfWork' key to create a new Work
del manifestation_data['manifestationOfWork']
# Set the persisted ids of the entities
mock_plugin.save.side_effect = create_entity_id_setter(
mock_work_create_id,
mock_manifestation_create_id,
mock_copyright_create_id,
type_key='type' if data_format == 'json' else '@type',
)
# Set up the data format
register_manifestation_kwargs = {}
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format_arg = get_data_format_enum_member(data_format)
else:
data_format_arg = data_format
register_manifestation_kwargs['data_format'] = data_format_arg
# Create the entities and test they contain the right links
manifestation_copyright, manifestation, work = mock_coalaip.register_manifestation(
manifestation_data,
copyright_holder=alice_user,
**register_manifestation_kwargs
)
assert manifestation_copyright.data['rightsOf'] == manifestation.persist_id
assert manifestation.data['manifestationOfWork'] == work.persist_id
# Test the entities were persisted with the set persisted ids
assert manifestation_copyright.persist_id == mock_copyright_create_id
assert manifestation.persist_id == mock_manifestation_create_id
assert work.persist_id == mock_work_create_id
# Test the correct data format was persisted
if data_format == 'json':
manifestation_persisted_data = manifestation.to_json()
copyright_persisted_data = manifestation_copyright.to_json()
work_persisted_data = work.to_json()
elif data_format == 'ipld':
raise NotImplementedError('IPLD is not implemented yet')
else:
manifestation_persisted_data = manifestation.to_jsonld()
copyright_persisted_data = manifestation_copyright.to_jsonld()
work_persisted_data = work.to_jsonld()
# By checking we called plugin.save() in the right order
mock_save_call_list = mock_plugin.save.call_args_list
assert len(mock_save_call_list) == 3
assert mock_save_call_list[0] == (
(work_persisted_data,),
{'user': alice_user},
)
assert mock_save_call_list[1] == (
(manifestation_persisted_data,),
{'user': alice_user},
)
assert mock_save_call_list[2] == (
(copyright_persisted_data,),
{'user': alice_user},
)
def test_register_manifestation(mock_plugin, mock_coalaip, manifestation_data,
alice_user, data_format, use_data_format_enum,
mock_work_create_id,
mock_manifestation_create_id,
mock_copyright_create_id):
from tests.utils import create_entity_id_setter
# Remove the 'manifestationOfWork' key to create a new Work
del manifestation_data['manifestationOfWork']
# Set the persisted ids of the entities
mock_plugin.save.side_effect = create_entity_id_setter(
mock_work_create_id,
mock_manifestation_create_id,
mock_copyright_create_id,
type_key='type' if data_format == 'json' else '@type',
)
# Set up the data format
register_manifestation_kwargs = {}
if data_format:
if use_data_format_enum:
from tests.utils import get_data_format_enum_member
data_format_arg = get_data_format_enum_member(data_format)
else:
data_format_arg = data_format
register_manifestation_kwargs['data_format'] = data_format_arg
# Create the entities and test they contain the right links
manifestation_copyright, manifestation, work = mock_coalaip.register_manifestation(
manifestation_data,
copyright_holder=alice_user,
**register_manifestation_kwargs)
assert manifestation_copyright.data['rightsOf'] == manifestation.persist_id
assert manifestation.data['manifestationOfWork'] == work.persist_id
# Test the entities were persisted with the set persisted ids
assert manifestation_copyright.persist_id == mock_copyright_create_id
assert manifestation.persist_id == mock_manifestation_create_id
assert work.persist_id == mock_work_create_id
# Test the correct data format was persisted
if data_format == 'json':
manifestation_persisted_data = manifestation.to_json()
copyright_persisted_data = manifestation_copyright.to_json()
work_persisted_data = work.to_json()
elif data_format == 'ipld':
raise NotImplementedError('IPLD is not implemented yet')
else:
manifestation_persisted_data = manifestation.to_jsonld()
copyright_persisted_data = manifestation_copyright.to_jsonld()
work_persisted_data = work.to_jsonld()
# By checking we called plugin.save() in the right order
mock_save_call_list = mock_plugin.save.call_args_list
assert len(mock_save_call_list) == 3
assert mock_save_call_list[0] == (
(work_persisted_data, ),
{
'user': alice_user
},
)
assert mock_save_call_list[1] == (
(manifestation_persisted_data, ),
{
'user': alice_user
},
)
assert mock_save_call_list[2] == (
(copyright_persisted_data, ),
{
'user': alice_user
},
)
