def test_post_filtered_by_wrong_workspace_id_returns_no_data(self):
# Arrange
self.data.update({
"query": "{}",
"workspaces": [{
"id": "507f1f77bcf86cd799439011"
}]
})
# Act
response = RequestMock.do_request_post(
data_rest_views.ExecuteLocalQueryView.as_view(),
self.user,
data=self.data)
# Assert
self.assertEqual(len(response.data), 0)
def test_duplicate_argument(self, mock_get, mock_request):
# Arrange
mock_get.return_value.enable_harvesting = True
mock_request.return_value = ""
bad_arg = {"verb": ["ListSets", "ListSets"]}
# Act
response = RequestMock.do_request_get(OAIProviderView.as_view(),
None,
data=bad_arg)
# Assert
self.assertTrue(
isinstance(response.context_data["errors"][0],
exceptions.BadArgument))
self.check_tag_error_code(response.rendered_content,
exceptions.BAD_ARGUMENT)
def test_post_query_string_filtered_by_templates_returns_one_data(self):
# Arrange
self.data.update({
"query": '{"root.element": "value"}',
"templates": [{
"id": str(self.fixture.template.id)
}],
})
# Act
response = RequestMock.do_request_post(
data_rest_views.ExecuteLocalQueryView.as_view(),
self.user,
data=self.data)
# Assert
self.assertEqual(len(response.data), 1)
def test_post_query_string_filter_by_private_workspace_returns_all_data_with_no_workspace_as_user(
self, ):
# Arrange
self.data.update({"query": "{}", "workspaces": [{"id": "None"}]})
# Act
response = RequestMock.do_request_post(
data_rest_views.ExecuteLocalQueryView.as_view(),
self.user2,
data=self.data)
# Assert
self.assertEqual(len(response.data), 1)
for data in response.data:
self.assertEqual(data["workspace"], None)
self.assertEqual(data["user_id"], self.user2.id)
def test_get_list_metadata_formats_with_identifier(
self, mock_get_metadata_format_schema_url):
# Arrange
data = {
"verb": "ListMetadataFormats",
"identifier": self.fixture.data_identifiers[0],
}
mock_get_metadata_format_schema_url.return_value = "dummy_schema"
# Act
response = RequestMock.do_request_get(OAIProviderView.as_view(),
user=_create_user("1"),
data=data)
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.check_tag_exist(response.rendered_content, "ListMetadataFormats")
def test_get_record(self, mock_xml_content):
# Arrange
mock_xml_content.return_value = "<tag>value</tag>"
data = {
"verb": "GetRecord",
"metadataPrefix": "oai_demo",
"identifier": self.fixture.data_identifiers[0],
}
# Act
response = RequestMock.do_request_get(OAIProviderView.as_view(),
user=_create_user("1"),
data=data)
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.check_tag_exist(response.rendered_content, "record")
def test_get_returns_http_400_when_data_not_well_formatted(
self, mock_data_api_get_by_id):
# Arrange
mock_user = create_mock_user("1")
mock_data = Data(user_id="1")
mock_data_api_get_by_id.return_value = mock_data
# Mock
response = RequestMock.do_request_get(
data_rest_views.DataDownload.as_view(),
mock_user,
param={"pk": "1"},
data={"pretty_print": "true"},
)
# Assert
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_post_template_with_incorrect_dependency_schemaLocation_returns_http_400(
self):
# Arrange
user = create_mock_user('1')
self.data['content'] = "<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>" \
"<xs:include schemaLocation='template1_1.xsd'/>" \
"<xs:element name='root'/></xs:schema>"
self.data['dependencies_dict'] = json.dumps(
{"test.xsd": str(self.fixture.template_1_1.id)})
# Act
response = RequestMock.do_request_post(
views.UserTemplateList.as_view(), user, data=self.data)
# Assert
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_template_to_metadata_format_mapping_xslt_metadata_format_not_found(
self, mock_get_xslt, mock_get_template, mock_get_by_id):
# Arrange
mock_get_xslt.return_value = Mock(spec=XslTransformation)
mock_get_template.return_value = Mock(spec=Template)
mock_get_by_id.side_effect = exceptions.DoesNotExist("Error")
# Act
response = RequestMock.do_request_post(
rest_oai_provider_metadata_format.TemplateMetadataFormatXSLT.
as_view(),
user=create_mock_user("1", is_staff=True),
data=self.data,
)
# Assert
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_staff_returns_http_200(self,
mock_oaipmhmessage_get_message_labelled,
mock_oai_registry_api_upsert,
mock_oai_registry_api_get_by_id):
# Arrange
mock_oaipmhmessage_get_message_labelled.return_value = None
mock_oai_registry_api_upsert.return_value = None
mock_oai_registry_api_get_by_id.return_value = Mock(spec=OaiRegistry)
# Act
response = RequestMock.do_request_patch(
rest_oai_registry.DeactivateRegistry.as_view(),
user=create_mock_user('1', is_staff=True),
param=self.param)
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_staff_returns_http_200(
self,
template_to_mf_mapping_xslt_serializer_init_instance,
template_to_mf_mapping_xslt_serializer_save,
template_to_mf_mapping_xslt_serializer_is_valid,
):
template_to_mf_mapping_xslt_serializer_save.return_value = None
template_to_mf_mapping_xslt_serializer_is_valid.return_value = {}
template_to_mf_mapping_xslt_serializer_init_instance.return_value = None
mock_user = create_mock_user("1", is_staff=True)
response = RequestMock.do_request_post(
metadata_format_views.TemplateMetadataFormatXSLT.as_view(),
mock_user)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_staff_returns_http_201(
self,
template_metadata_format_serializer_save,
template_metadata_format_serializer_is_valid,
):
# method returns serializer.save directly (which returns an HTTPResponse with status code 201 automatically)
template_metadata_format_serializer_save.return_value = (
_create_mock_http_response(status.HTTP_201_CREATED))
template_metadata_format_serializer_is_valid.return_value = {}
mock_user = create_mock_user("1", is_staff=True)
response = RequestMock.do_request_post(
metadata_format_views.TemplateAsMetadataFormat.as_view(),
mock_user)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_staff_returns_http_200(
self,
oai_provider_metadata_format_serializer_data,
oai_provider_metadata_format_get_by_id,
):
oai_provider_metadata_format_serializer_data.return_value = True
oai_provider_metadata_format_get_by_id.return_value = {}
mock_user = create_mock_user("1", is_staff=True)
response = RequestMock.do_request_get(
metadata_format_views.MetadataFormatDetail.as_view(),
mock_user,
param={"metadata_format_id": self.fake_id},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_post_authenticated_returns_http_201(self,
mock_data_serializer_save,
mock_data_serializer_is_valid,
mock_data_serializer_data):
# Context
user = create_mock_user('1')
mock_data_serializer_is_valid.return_value = True
mock_data_serializer_save.return_value = None
mock_data_serializer_data.return_value = []
# Act
response = RequestMock.do_request_post(
workspace_rest_views.WorkspaceList.as_view(),
user,
data={"title": "title 1"})
# Assert
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_get_record_missing_metadata_prefix(self, mock_get, mock_request):
# Arrange
mock_get.return_value = _create_mock_oai_settings()
mock_request.return_value = ""
data = {"verb": "GetRecord", "identifier": "dummy"}
# Act
response = RequestMock.do_request_get(OAIProviderView.as_view(),
None,
data=data)
# Assert
self.assertTrue(
isinstance(response.context_data["errors"][0],
exceptions.BadArgument))
self.check_tag_error_code(response.rendered_content,
exceptions.BAD_ARGUMENT)
def test_authenticated_returns_http_200(self, mock_exporter_get_by_name,
mock_data_api_get_by_id):
template = Template()
mock_user = create_mock_user("1")
mock_exporter_get_by_name.return_value = _create_exporter(template)
mock_data_api_get_by_id.return_value = _create_data(template)
response = RequestMock.do_request_get(
export_api_views.ExportData.as_view(),
mock_user,
data={
"data_id": "6111b84691cb057052b3da20",
"exporter": "XML"
},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_staff_returns_http_200(
self,
mock_data_api_get_by_id,
mock_data_serializer_is_valid,
mock_data_serializer_save,
mock_data_serializer_data,
):
mock_data_api_get_by_id.return_value = []
mock_data_serializer_is_valid.return_value = True
mock_data_serializer_save.return_valie = None
mock_data_serializer_data.return_value = []
mock_user = create_mock_user("1", is_staff=True)
response = RequestMock.do_request_patch(
data_rest_views.DataDetail.as_view(), mock_user, param={"pk": 0})
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_export_data_wrong_exporter_returns_http_404(
self, mock_data_api_get_by_id):
# Arrange
user = create_mock_user("1")
mock_data_api_get_by_id.return_value = self.data
# Act
response = RequestMock.do_request_get(
export_data_views.ExportData.as_view(),
user,
data={
"data_id": mock_data_api_get_by_id.return_value.id,
"exporter": "test",
},
)
# Assert
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_list_records_no_xml_data(self, mock_get, mock_request, mock_get_templates_id,
mock_get_by_metadata_prefix, mock_get_templates_id_by_set_spec,
mock_get_all_by_template):
# Arrange
mock_get.return_value = _create_mock_oai_settings()
mock_request.return_value = ""
mock_get_templates_id.return_value = [ObjectId()]
mock_get_by_metadata_prefix.return_value = []
mock_get_templates_id_by_set_spec.return_value = []
mock_get_all_by_template.return_value = []
data = {'verb': 'ListRecords', 'metadataPrefix': 'dummy', 'set': 'dummy_set'}
# Act
response = RequestMock.do_request_get(OAIProviderView.as_view(), None, data=data)
# Assert
self.assertTrue(isinstance(response.context_data['errors'][0], exceptions.NoRecordsMatch))
self.check_tag_error_code(response.rendered_content, exceptions.NO_RECORDS_MATCH)
def test_get_without_pretty_print_returns_data(self,
mock_template_api_get):
# Arrange
mock_user = create_mock_user("1")
mock_template = _get_template()
mock_template_api_get.return_value = mock_template
expected_value = b'<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="tag"></xs:element></xs:schema>'
# Mock
response = RequestMock.do_request_get(
template_rest_views.TemplateDownload.as_view(),
mock_user,
param={"pk": "1"},
data={"pretty_print": "false"},
)
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.content, expected_value)
def test_export_data_returns_status_200(self,
mock_data_api_get_by_pid):
# Arrange
user = create_mock_user("1")
mock_data_api_get_by_pid.return_value = self.data
# Act
response = RequestMock.do_request_get(
export_data_views.ExportData.as_view(),
user,
data={
"data_pid": mock_data_api_get_by_pid.return_value.id,
"exporter": self.fixture.exporter_xml.name,
},
)
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_staff_returns_http_200(self, mock_data_api_get_by_id,
mock_workspace_api_get_by_id,
mock_data_api_assign):
mock_data_api_get_by_id.return_value = None
mock_workspace_api_get_by_id.return_value = None
mock_data_api_assign.return_value = None
mock_user = create_mock_user('1', is_staff=True)
response = RequestMock.do_request_patch(
data_rest_views.DataAssign.as_view(),
mock_user,
param={
"pk": 0,
"workspace_id": 0
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_authenticated_returns_http_403(self, mock_data_api_get_by_id,
mock_user_api_get_by_id,
mock_data_api_change_owner):
mock_data_api_get_by_id.return_value = None
mock_user_api_get_by_id.return_value = None
mock_data_api_change_owner.return_value = None
mock_user = create_mock_user('1')
response = RequestMock.do_request_patch(
data_rest_views.DataChangeOwner.as_view(),
mock_user,
param={
"pk": 0,
"user_id": 0
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_assign_bad_workspace_id_returns_http_404(self, data_get_by_id):
# Arrange
fake_workspace_id = '507f1f77bcf86cd799439011'
data = self.fixture.data_collection[self.fixture.USER_1_WORKSPACE_1]
user = create_mock_user(data.user_id, is_superuser=True)
data_get_by_id.return_value = data
# Act
response = RequestMock.do_request_patch(
data_rest_views.DataAssign.as_view(),
user,
param={
'pk': data.id,
'workspace_id': fake_workspace_id
})
# Assert
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_staff_returns_http_200(
self,
mock_abstract_exporter_export,
mock_data_get_by_id_list,
mock_exported_compressed_file_upsert,
mock_exporter_exporter_is_valid,
mock_exporter_exporter_data,
):
mock_data_get_by_id_list.return_value = None
mock_user = create_mock_user("1", is_staff=True)
response = RequestMock.do_request_post(
exporters_api_views.ExportToZip.as_view(),
mock_user,
data={"data_id_list": "0", "exporter_id_list": ""},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_get_returns_http_200(self, data_get_by_id, workspace_get_by_id):
# Arrange
data = self.fixture.data_collection[self.fixture.USER_1_WORKSPACE_1]
user = create_mock_user(data.user_id, is_superuser=True)
data_get_by_id.return_value = data
workspace_get_by_id.return_value = self.fixture.workspace_1
# Act
response = RequestMock.do_request_patch(
data_rest_views.DataAssign.as_view(),
user,
param={
'pk': data.id,
'workspace_id': self.fixture.workspace_1.id
})
# Assert
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_post_empty_query_string_filter_by_templates_returns_all_data_of_the_template(
self):
# Arrange
self.data.update({
"query":
"{}",
"templates":
'[{"id": "' + str(self.fixture.template.id) + '"}]'
})
# Act
response = RequestMock.do_request_post(
data_rest_views.ExecuteLocalQueryView.as_view(),
self.user,
data=self.data)
# Assert
self.assertEqual(len(response.data), 2)
def test_assign_bad_data_id_returns_http_404(self, workspace_get_by_id):
# Arrange
fake_data_id = "507f1f77bcf86cd799439011"
user = create_mock_user("1", is_superuser=True)
workspace_get_by_id.return_value = self.fixture.workspace_2
# Act
response = RequestMock.do_request_patch(
data_rest_views.DataAssign.as_view(),
user,
param={
"pk": fake_data_id,
"workspace_id": self.fixture.workspace_2.id
},
)
# Assert
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_post_query_string_filtered_by_wrong_template_id_returns_no_data(
self):
# Arrange
self.data.update({
"query": '{"root.element": "value"}',
"templates": [{
"id": "507f1f77bcf86cd799439011"
}],
})
# Act
response = RequestMock.do_request_post(
data_rest_views.ExecuteLocalQueryView.as_view(),
self.user,
data=self.data)
# Assert
self.assertEqual(len(response.data), 0)
def test_is_staff_returns_http_200(self, xslt_serializer_data,
xslt_serializer_save,
xslt_serializer_is_valid,
xslt_get_by_id):
xslt_get_by_id.return_value = {}
xslt_serializer_is_valid.return_value = {}
xslt_serializer_save.return_value = None
xslt_serializer_data.return_value = True
mock_user = create_mock_user('1', is_staff=True)
response = RequestMock.do_request_patch(
xslt_views.XslTransformationDetail.as_view(),
mock_user,
param={'pk': self.fake_id},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
