def generate_data_collection(self):
""" Generate a Data collection.
Returns:
"""
content_1 = {
"root": {
"element": "value",
"list": [
{"element_list_1": 1},
{"element_list_2": 2}
],
"complex": {
"child1": "test",
"child2": 0
}
}
}
content_2 = {
"root": {
"element": "value2"
}
}
# NOTE: no xml_content to avoid using unsupported GridFS mock
self.data_1 = Data(template=self.template, user_id='1', dict_content=content_1,
title='title').save()
self.data_2 = Data(template=self.template, user_id='2', dict_content=content_2,
title='title2').save()
self.data_collection = [self.data_1, self.data_2]
def generate_data_collection(self):
""" Generate a Data collection.
Returns:
"""
data_1 = Data(template=self.template,
title='Data 1',
user_id='1').save()
self.data_user_1.append(data_1)
data_2 = Data(template=self.template,
title='Data 2',
user_id='2').save()
self.data_user_2.append(data_2)
data_3 = Data(template=self.template,
title='Data 3',
user_id='1',
workspace=self.workspace_1.id).save()
self.data_user_1.append(data_3)
data_4 = Data(template=self.template,
title='Data 4',
user_id='2',
workspace=self.workspace_2.id).save()
self.data_user_2.append(data_4)
self.data_collection = [data_1, data_2, data_3, data_4]
def generate_data_collection(self):
""" Generate a Data collection.
Returns:
"""
self.data_1 = Data(template=self.template,
title='Data 1',
user_id='1').save()
self.data_2 = Data(template=self.template,
title='Data 2',
user_id='2').save()
self.data_3 = Data(template=self.template,
title='Data 3',
user_id='1',
workspace=self.workspace_1.id).save()
self.data_4 = Data(template=self.template,
title='DataDoubleTitle',
user_id='2',
workspace=self.workspace_2.id).save()
self.data_5 = Data(template=self.template,
title='DataDoubleTitle',
user_id='1',
workspace=self.workspace_1.id).save()
self.data_collection = [self.data_1, self.data_2, self.data_3, self.data_4, self.data_5]
def generate_data_collection(self):
"""Generate a Data collection.
Returns:
"""
content = {"root": {"element": "value2"}}
self.data_no_workspace = Data(template=self.template,
title="Data 1",
user_id="1").save()
self.data_workspace_1 = Data(
template=self.template,
title="Data 3",
user_id="1",
workspace=self.workspace_user1.id,
dict_content=content,
).save()
self.data_public_workspace = Data(
template=self.template,
title="DataDoubleTitle",
user_id="2",
workspace=self.public_workspace.id,
).save()
self.data_collection = [
self.data_no_workspace,
self.data_workspace_1,
self.data_public_workspace,
]
def generate_data_collection(self):
"""Generate a Data collection.
Returns:
"""
self.data_1 = Data(template=self.template_1,
title="Data 1",
user_id="1")
self.data_1.xml_content = '<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> \
<test>test</test> \
</root>'
self.data_1.save()
self.data_2 = Data(template=self.template_1,
title="Data 2",
user_id="1")
self.data_2.xml_content = '<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> \
<test>test</test> \
</root>'
self.data_2.save()
self.data_3 = Data(template=self.template_2,
title="Data 3",
user_id="1")
self.data_3.xml_content = '<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> \
<test>test</test> \
</root>'
self.data_3.save()
self.data_4 = Data(template=self.template_3,
title="Data4",
user_id="1")
self.data_4.xml_content = '<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> \
<other>test</other> \
</root>'
self.data_4.save()
self.data_5 = Data(template=self.template_3,
title="Data5",
user_id="1")
self.data_5.xml_content = '<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> \
<other>test</other> \
</root>'
self.data_5.save()
self.data_collection = [
self.data_1,
self.data_2,
self.data_3,
self.data_4,
self.data_5,
]
def generate_data_collection(self):
""" Generate a Data collection.
Returns:
"""
# NOTE: no xml_content to avoid using unsupported GridFS mock
self.data_1 = Data(self.template, '1', None, 'title').save()
self.data_2 = Data(self.template, '2', None, 'title2').save()
self.data_collection = [self.data_1, self.data_2]
def generate_data_collection(self):
""" Generate a Data collection.
Returns:
"""
# NOTE: no xml_content to avoid using unsupported GridFS mock
self.data_1 = Data(template=self.template, user_id='1', dict_content=None,
title='title').save()
self.data_2 = Data(template=self.template, user_id='2', dict_content=None,
title='title2').save()
self.data_3 = Data(template=self.template, user_id='1', dict_content=None,
title='title3').save()
self.data_collection = [self.data_1, self.data_2, self.data_3]
def create(self, validated_data):
"""
Create and return a new `Data` instance, given the validated data.
"""
# Create data
instance = Data(
template=validated_data["template"],
workspace=validated_data["workspace"]
if "workspace" in validated_data
else None,
title=validated_data["title"],
user_id=str(self.context["request"].user.id),
)
# Get template
template_api.get(instance.template.id, request=self.context["request"])
# Set xml content
instance.xml_content = validated_data["xml_content"]
# Save the data and retrieve the inserted object
inserted_data = data_api.upsert(instance, self.context["request"])
# Encode the response body
inserted_data.xml_content = inserted_data.xml_content.encode("utf-8")
return inserted_data
def generate_data_collection(self):
"""Generate a Data collection.
Returns:
"""
# NOTE: no xml_content to avoid using unsupported GridFS mock
self.data = Data(template=self.template,
user_id="1",
dict_content=None,
title="title").save()
self.data_structure_1 = CurateDataStructure(user="******",
template=self.template,
name="data_structure_1",
data=self.data).save()
self.data_structure_2 = CurateDataStructure(
user="******", template=self.template, name="data_structure_2").save()
self.data_structure_3 = CurateDataStructure(
user="******", template=self.template, name="data_structure_3").save()
self.data_collection = [
self.data_structure_1,
self.data_structure_2,
self.data_structure_3,
self.data,
]
def mock_data(version=""):
with open(join(DUMP_OAI_PMH_TEST_PATH,
"data{0}.json".format(version))) as f:
data = f.read()
data_json = json.loads(data)
list_data = [Data(**x) for x in data_json]
return list_data
def create(self, validated_data):
"""
Create and return a new `Data` instance, given the validated data.
"""
# Create data
instance = Data(
template=validated_data["template"],
workspace=validated_data["workspace"]
if "workspace" in validated_data else None,
title=validated_data["title"],
user_id=validated_data["user_id"] if "user_id" in validated_data
else str(self.context["request"].user.id),
)
# Set XML content
instance.xml_content = validated_data["xml_content"]
# Set times
instance.creation_date = validated_data.get("creation_date", None)
instance.last_modification_date = validated_data.get(
"last_modification_date", None)
instance.last_change_date = validated_data.get("last_change_date",
None)
# Save the data
data_api.admin_insert(instance, request=self.context["request"])
# Encode the response body
# NOTE: using xml_content property would update the last_modification_date
instance._xml_content = validated_data["xml_content"].encode("utf-8")
return instance
def _create_data(template, xml):
data = Data(template=template,
user_id='1',
dict_content=None,
title='title')
data.xml_content = xml
data.convert_to_dict()
return data.save()
def test_get_by_data_raises_exception_if_internal_error(
self, mock_get_by_data):
# Arrange
mock_absent_data = Data()
mock_get_by_data.side_effect = exceptions.ModelError("Error.")
# Act + Assert
with self.assertRaises(exceptions.ModelError):
oai_data_api.get_by_data(mock_absent_data)
def test_system_get_all_except_inexistant_id_return_data_object(
self, mock_get_all_except):
mock_data = Data(template=_get_template(),
user_id='1',
dict_content=OrderedDict(),
title='title')
mock_get_all_except.return_value = [mock_data]
result = system_api.get_all_except(["1"])
self.assertTrue(all(isinstance(item, Data) for item in result))
def test_system_get_all_except_inexistant_id_return_correct_count(
self, mock_get_all_except):
mock_data = Data(template=_get_template(),
user_id='1',
dict_content=OrderedDict(),
title='title')
mock_get_all_except.return_value = [mock_data]
result = system_api.get_all_except(["1"])
self.assertEqual(len(result), 1)
def test_data_get_by_id_return_data_if_found(self, mock_get):
# Arrange
mock_data = Data(template=_get_template(), user_id='1', dict_content=OrderedDict(),
title='title')
mock_get.return_value = mock_data
mock_user = _create_user('1')
# Act
result = data_api.get_by_id(1, mock_user)
# Assert
self.assertIsInstance(result, Data)
def test_get_by_data_raises_exception_if_object_does_not_exist(
self, mock_get_by_data):
# Arrange
mock_absent_data = Data()
mock_get_by_data.side_effect = exceptions.DoesNotExist("Error.")
# Act + Assert
with self.assertRaises(exceptions.DoesNotExist):
oai_data_api.get_by_data(mock_absent_data)
def save_data(request):
"""Save data - delete curate data structure.
Args:
request:
Returns:
"""
try:
# get curate data structure
curate_data_structure_id = request.POST["id"]
curate_data_structure = curate_data_structure_api.get_by_id(
curate_data_structure_id, request.user)
# unlock from database
if curate_data_structure.data is not None:
lock_api.remove_lock_on_object(curate_data_structure.data,
request.user)
# generate the XML
xml_data = render_xml(
request, curate_data_structure.data_structure_element_root)
if curate_data_structure.data is not None:
# update existing data
data = curate_data_structure.data
else:
# create new data
data = Data()
data.title = curate_data_structure.name
template = template_api.get(str(curate_data_structure.template.id),
request=request)
data.template = template
data.user_id = str(request.user.id)
# set content
data.xml_content = xml_data
# save data
data = data_api.upsert(data, request)
curate_data_structure_api.delete(curate_data_structure, request.user)
messages.add_message(
request,
messages.SUCCESS,
get_data_label().capitalize() + " saved with success.",
)
except Exception as e:
return HttpResponseBadRequest(str(e).replace('"', "'"),
content_type="application/javascript")
return HttpResponse(json.dumps({"data_id": str(data.id)}),
content_type="application/javascript")
def test_none_returns_correct_count(self, mock_get_all_by_list_workspace):
mock_data = Data(
template=_get_template(),
workspace=_get_workspace(),
user_id="1",
dict_content=OrderedDict(),
title="mock_title",
)
mock_get_all_by_list_workspace.return_value = [mock_data]
result = system_api.get_all_data_in_workspaces([None])
self.assertEqual(len(result), 1)
def test_anonymous_returns_http_200(self, mock_data_get_by_id):
mock_data = Data(template="template",
user_id="1",
dict_content=OrderedDict(),
title="title")
mock_data_get_by_id.return_value = mock_data
response = RequestMock.do_request_get(get_result_from_data_id,
None,
data={"id": 0})
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_none_returns_data_object(self, mock_get_all_by_list_workspace):
mock_data = Data(
template=_get_template(),
workspace=_get_workspace(),
user_id="1",
dict_content=OrderedDict(),
title="mock_title",
)
mock_get_all_by_list_workspace.return_value = [mock_data]
result = system_api.get_all_data_in_workspaces([None])
self.assertTrue(all(isinstance(item, Data) for item in result))
def test_get_by_data_returns_object(self, mock_get_by_data):
# Arrange
mock_oai_data = _create_oai_data()
mock_oai_data.data = Data()
mock_get_by_data.return_value = mock_oai_data
# Act
result = oai_data_api.get_by_data(mock_get_by_data.data)
# Assert
self.assertIsInstance(result, OaiData)
def test_system_get_all_except_empty_list_return_correct_count(
self, mock_get_all_except):
mock_data = Data(
template=_get_template(),
user_id="1",
dict_content=OrderedDict(),
title="title",
)
mock_get_all_except.return_value = [mock_data]
result = system_api.get_all_except([])
self.assertEqual(len(result), 1)
def test_staff_returns_http_200(self, get_by_id):
mock_user = create_mock_user("1", is_staff=True)
mock_data = Data(user_id="1")
get_by_id.return_value = mock_data
response = RequestMock.do_request_get(
data_rest_views.DataPermissions.as_view(),
mock_user,
data={"ids": f'["{mock_data.id}"]'},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def _create_data(title="test"):
"""Create a data
Args:
title:
Returns:
"""
data = Data(title=title, template="6137af4b91cb055990297f35", user_id="1")
data.template = _get_template()
data.xml_content = '<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ><string>x</string></root>'
return data
def test_check_if_workspace_can_be_changed_return_true_if_workspace_is_none_and_allow_public_is_false(
self):
# A global workspace is public
data = Data(template=Template(),
user_id='1',
dict_content=None,
title='title',
workspace=None)
# Act
result = workspace_api.check_if_workspace_can_be_changed(data, False)
# Assert
self.assertEquals(result, True)
def test_staff_returns_http_200(self, mock_data_get_by_id):
mock_data = Data(template="template",
user_id="1",
dict_content=OrderedDict(),
title="title")
mock_data_get_by_id.return_value = mock_data
mock_user = create_mock_user("1", is_staff=True)
response = RequestMock.do_request_get(get_result_from_data_id,
mock_user,
data={"id": 0})
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_check_if_workspace_can_be_changed_return_true_if_workspace_is_public_and_allow_public_is_true(
self):
# A global workspace is public
workspace = WorkspaceFixtures.create_global_workspace(TITLE_1)
data = Data(template=Template(),
user_id='1',
dict_content=None,
title='title',
workspace=workspace)
# Act
result = workspace_api.check_if_workspace_can_be_changed(data, True)
# Assert
self.assertEquals(result, True)
def _create_data(template, title="test"):
"""Create a data
Args:
template
title:
Returns:
"""
data = Data(title=title, template="6137af4b91cb055990297f35", user_id="1")
data.id = "6111b84691cb057552b3da20"
data.template = template
data.xml_content = "<root xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><test>value</test></root>"
return data
def _set_oai_data_fields(oai_data):
""" Set OaiData fields.
Returns:
OaiData with assigned fields.
"""
oai_data.status = status.ACTIVE
oai_data.data = Data()
oai_data.template = Template()
oai_data.oai_date_stamp = datetime.now()
return oai_data
