def test_view_readonly_with_fields(self):
self.add_admin_credentials()
detail_url = reverse('accession-detail',
kwargs={
'institute_code': 'ESP004',
'germplasm_number': 'BGE0001'
})
response = self.client.get(detail_url, data={'fields': 'institute'})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Passed fields are not allowed'])
response = self.client.get(detail_url, data={'fields': INSTITUTE_CODE})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['data'][INSTITUTE_CODE], 'ESP004')
self.assertEqual(len(response.json()['data'].keys()), 1)
response = self.client.get(
detail_url, data={'fields': 'instituteCode,passports,genera'})
self.assertEqual(response.json()['data'][INSTITUTE_CODE], 'ESP004')
self.assertEqual(len(response.json()['data'][PASSPORTS]), 1)
self.assertEqual(len(response.json()['data'].keys()), 3)
self.assertEqual(response.json()['data']['genera'], ['Solanum'])
list_url = reverse('accession-list')
response = self.client.get(list_url,
data={'fields': 'instituteCode,passp'})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Passed fields are not allowed'])
def test_create_delete(self):
self.add_admin_credentials()
list_url = reverse('scale-list')
api_data = {
"name": "milimeter",
"description": "milimeter",
"data_type": "Numerical",
"decimal_places": 0,
"max": 0,
"min": 0,
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# bad data
bad_api_data = {
"name": "milimeter",
"description": "milimeter",
"decimal_places": 0,
"max": 0,
"min": 0
}
response = self.client.post(list_url, data=bad_api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['data_type mandatory'])
# adding agian should fail
with transaction.atomic():
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
detail_url = reverse('scale-detail', kwargs={"name": "milimeter"})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_create(self):
self.add_user_credentials()
list_url = reverse('accession-list')
api_data = {
'data': {
INSTITUTE_CODE: 'ESP004',
'germplasmNumber': 'BGE0005'
},
'metadata': {
'group': 'admin',
'is_public': True
}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['can not set group or is public while creating the accession'])
api_data = {
'data': {
INSTITUTE_CODE: 'ESP004',
'germplasmNumber': 'BGE0005'
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.json()['metadata'], {
'group': 'userGroup',
'is_public': False
})
def test_create_delete(self):
self.add_admin_credentials()
list_url = reverse('plant-list')
api_data = {
"data": {"name": "Plant size2"},
"metadata": {}}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# bad data
bad_api_data = {
"data": {
"description": "Measure of plant heigth",
"method": "by tape",
"data_type": "Numerical",
"unit": "centimeter"},
"metadata": {}}
response = self.client.post(list_url, data=bad_api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['name mandatory'])
# adding agian should fail
with transaction.atomic():
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
detail_url = reverse('plant-detail',
kwargs={"name": "Plant size2"})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_update_observation_unit_with_plant(self):
self.add_admin_credentials()
detail_url = reverse('observationunit-detail',
kwargs={'name': 'Plant 1'})
response = self.client.get(detail_url)
api_data = response.json()
api_data['data']['plants'] = ['Plant 1', "Plant 2"]
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.json(), api_data)
response = self.client.get(detail_url)
self.assertEqual(response.json(), api_data)
self.add_user_credentials()
detail_url = reverse('observationunit-detail',
kwargs={'name': 'Plant 3'})
response = self.client.get(detail_url)
api_data = response.json()
api_data['data']['plants'] = ['Plant 3', "Plant 1"]
response = self.client.put(detail_url, data=api_data, format='json')
assert_error_is_equal(
response.json(),
['Can not add plant you dont own to observation unit: Plant 1'])
api_data['data']['plants'] = []
response = self.client.put(detail_url, data=api_data, format='json')
def test_update(self):
self.add_admin_credentials()
detail_url = reverse('plant-detail',
kwargs={'name': 'Plant 1'})
response = self.client.get(detail_url)
api_data = response.json()
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# admin can change group
api_data['metadata']['group'] = 'userGroup'
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# Fail changing group if not exists
api_data = {
'data': {
'name': 'Plant 1'},
'metadata': {'group': 'rGroup'}}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Provided group does not exist in db: rGroup'])
def test_bulk_create(self):
self.add_admin_credentials()
list_url = reverse('plant-list')
api_data = [
{
'data': {
'name': 'Plant 5'
},
'metadata': {
'group': 'userGroup'
}
},
{
'data': {
'name': 'Plant 6'
},
'metadata': {
'group': 'admin'
}
},
]
response = self.client.post(list_url + 'bulk/',
data=api_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), [
'can not set group while creating the plant',
'can not set group while creating the plant'
])
# correct data
api_data = [{
'data': {
'name': 'Plant 5'
},
'metadata': {}
}, {
'data': {
'name': 'Plant 6'
},
'metadata': {}
}]
response = self.client.post(list_url + 'bulk/',
data=api_data,
format='json')
self.assertEqual(len(response.json()), 2)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(len(self.client.get(list_url).json()), 6)
# Should fail, can not add again same item
response = self.client.post(list_url + 'bulk/',
data=api_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(len(response.json()[DETAIL]), 2)
self.assertEqual(len(self.client.get(list_url).json()), 6)
def test_create_delete(self):
self.add_admin_credentials()
list_url = reverse('observationvariable-list')
api_data = {
"data": {
"name": "Plant size2",
"trait": "Plant Growth type",
"description": "Measure of plant heigth",
"method": "by tape",
"scale": "centimeter"
},
"metadata": {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# bad data
bad_api_data = {
"data": {
"name": "Plant",
"description": "Measure of plant heigth",
"method": "by tape",
"scale": "centimeter"
},
"metadata": {}
}
response = self.client.post(list_url, data=bad_api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['trait mandatory'])
# adding agian should fail
with transaction.atomic():
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
detail_url = reverse('observationvariable-detail',
kwargs={"name": "Plant size2"})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# check name validator
bad_api_data = {
"data": {
"name": "Plant/kjhas",
"description": "Measure of plant heigth",
"trait": "Plant Growth type",
"method": "by tape",
"scale": "centimeter"
},
"metadata": {}
}
response = self.client.post(list_url, data=bad_api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), [
'Plant/kjhas: "\\", "/", "*", "<", ">", """ are not allowed characters'
])
def test_fail_create_by_endpoint(self):
if DO_TESTS:
request = self.create_request()
request.requested_accessions = [{'instituteCode': 'ESP058', 'germplasmNumber': 'BGE0003'}]
requests_url = reverse('seedrequest-list')
response = self.client.post(requests_url, format='json',
data=request.get_api_document())
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
["['This institute has no email to send requests ESP058']"])
def test_update(self):
self.add_admin_credentials()
detail_url = reverse('observationvariable-detail',
kwargs={'name': 'Plant size:cm'})
api_data = {
'data': {
'name': 'Plant size:cm',
'trait': 'Plant Growth type',
'description': 'Measure of plant heigth',
'method': 'by tape',
'scale': 'centimeter'
},
'metadata': {
'group': 'admin'
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# admin can change group
api_data = {
'data': {
'name': 'Plant size:cm',
'trait': 'Plant Growth type',
'description': 'Measure of plant heigth',
'method': 'by tape',
'scale': 'centimeter'
},
'metadata': {
'group': 'userGroup'
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# Fail changing group if not exists
api_data = {
'data': {
'name': 'Plant size:cm',
'trait': 'Plant Growth type',
'description': 'Measure of plant heigth',
'method': 'by tape',
'scale': 'centimeter'
},
'metadata': {
'group': 'rGroup'
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Provided group does not exist in db: rGroup'])
def test_update(self):
self.add_admin_credentials()
detail_url = reverse('accession-detail',
kwargs={
'institute_code': 'ESP004',
'germplasm_number': 'BGE0001'
})
api_data = {
'data': {
INSTITUTE_CODE: 'ESP004',
'germplasmNumber': 'BGE0001'
},
'metadata': {
'group': 'admin',
'is_public': False
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# admin can change group
api_data = {
'data': {
INSTITUTE_CODE: 'ESP004',
'germplasmNumber': 'BGE0001'
},
'metadata': {
'group': 'userGroup',
'is_public': True
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# Fail changing group if not exists
api_data = {
'data': {
INSTITUTE_CODE: 'ESP004',
'germplasmNumber': 'BGE0001'
},
'metadata': {
'group': 'rGroup',
'is_public': True
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Provided group does not exist in db: rGroup'])
def test_create_delete(self):
self.add_admin_credentials()
list_url = reverse('accessionset-list')
api_data = {'data': {'instituteCode': 'ESP004',
'accessionsetNumber': 'NC003'},
'metadata': {'group': 'admin', 'is_public': True}}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['can not set group or is public while creating the accession'])
api_data = {'data': {'instituteCode': 'ESP004',
'accessionsetNumber': 'NC003',
ACCESSIONS: [{INSTITUTE_CODE: 'ESP004',
GERMPLASM_NUMBER: 'BGE0004'}]},
'metadata': {}}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.json()['data'], api_data['data'])
# bad payload data
api_data = {'data': {'instituteCode': 'ESP004'},
'metadata': {}}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['accessionsetNumber mandatory'])
# already en db
with transaction.atomic():
api_data = {'data': {'instituteCode': 'ESP004',
'accessionsetNumber': 'NC003'},
'metadata': {}}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['This accessionset already exists in db: ESP004 NC003'])
detail_url = reverse('accessionset-detail',
kwargs={'institute_code': 'ESP004',
'accessionset_number': 'NC003'})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# cano not add accessionset if accessions not in db
api_data = {'data': {'instituteCode': 'ESP004',
'accessionsetNumber': 'NC004',
ACCESSIONS: [{INSTITUTE_CODE: 'ESP004',
GERMPLASM_NUMBER: 'fake'}]},
'metadata': {}}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['NC004: accession not found ESP004:fake'])
def test_filter(self):
self.add_admin_credentials()
list_url = reverse('study-list')
response = self.client.get(list_url, data={'name': 'study1'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 1)
response = self.client.get(list_url, data={'name_contains': 'study'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 5)
response = self.client.get(
list_url, data={'description__icontains': 'description'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 5)
response = self.client.get(list_url,
data={'location_contains': 'Valencia'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 4)
response = self.client.get(list_url,
data={'location_contains': 'valencia'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 4)
response = self.client.get(list_url, data={'is_active': True})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 4)
response = self.client.get(list_url, data={'is_active': False})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 1)
response = self.client.get(list_url, data={'is_public': False})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 3)
response = self.client.get(list_url)
response = self.client.get(list_url, data={'year': 2017})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 4)
response = self.client.get(list_url, data={'year': 201})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Year must be a string of 4 digits'])
def test_mine_and_not_public(self):
self.add_user_credentials()
detail_url = reverse('accession-detail',
kwargs={
'institute_code': 'ESP004',
'germplasm_number': 'BGE0004'
})
response = self.client.get(detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.client.put(detail_url, data={})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['Data key not present'])
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_user_can_not_change_group(self):
self.add_user_credentials()
detail_url = reverse('study-detail', kwargs={'name': 'study4'})
response = self.client.get(detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
api_data = deepcopy(response.json())
api_data['metadata']['group'] = 'admin'
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), [
'Can not change ownership if group does not belong to you : admin'
])
def test_create_delete(self):
self.add_admin_credentials()
list_url = reverse('observation-list')
api_data = {
'observation_variable': 'Plant size:cm',
'observation_unit': 'Plant 1',
'value': '99',
'observer': 'observer1',
'creation_time': '1911-12-03 00:23:00',
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
created_obj_id = response.json()['observation_id']
# bad data
bad_api_data = {
'observation_variable': 'Plant size:cm',
'value': '99',
'observer': 'observer1',
'creation_time': '1911-12-03 00:23:00'}
response = self.client.post(list_url, data=bad_api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['observation_unit mandatory'])
# adding again should fail
with transaction.atomic():
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
detail_url = reverse('observation-detail',
kwargs={"observation_id": created_obj_id})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# not valid value
api_data = {
'observation_variable': 'Plant size:cm',
'observation_unit': 'Plant 1',
'value': '121',
'observer': 'observer1',
'creation_time': '1911-12-03 00:23:00',
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['Plant 1: Plant size:cm: Numeric value is bigger than maxim: 121 > 100.0'])
def test_mine_and_not_public(self):
self.add_user_credentials()
detail_url = reverse('study-detail', kwargs={'name': 'study4'})
response = self.client.get(detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.client.put(detail_url, data={})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['Data key not present'])
api_data = {
'data': {
'name': "study4",
'description': "updated_description",
'start_date': "2018/01/17",
'end_date': "2020/12/01",
'location': "updated_city",
'contacts': "updated_contact"
},
'metadata': {
"group": "userGroup",
"is_public": False
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.client.get(detail_url)
api_data = {
'data': {
'name': "study4",
'description': "updated_description",
'start_date': "2018/01/17",
'end_date': "2020/12/01",
'location': "updated_city",
'contacts': "updated_contact"
},
'metadata': {
"group": "userGroup",
"is_public": True
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_create_delete(self):
self.add_admin_credentials()
list_url = reverse('observationunit-list')
api_data = {
"data": {
"name": "Plant 5",
"accession": {
"instituteCode": "ESP004",
"germplasmNumber": "BGE0001"
},
"level": "plant",
"replicate": "0",
"study": "study1"
},
"metadata": {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# bad data
bad_api_data = {
"data": {
"name": "Plant 5",
"accession": {
"instituteCode": "ESP004",
"germplasmNumber": "BGE0001"
},
"level": "plant",
"replicate": "0"
},
"metadata": {}
}
response = self.client.post(list_url, data=bad_api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['study mandatory'])
# adding agian should fail
with transaction.atomic():
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
detail_url = reverse('observationunit-detail',
kwargs={"name": "Plant 5"})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_view_readonly_with_fields(self):
self.add_admin_credentials()
detail_url = reverse('study-detail', kwargs={'name': 'study1'})
response = self.client.get(detail_url, data={'fields': 'institute'})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Passed fields are not allowed'])
response = self.client.get(detail_url, data={'fields': 'name'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['data']['name'], 'study1')
self.assertEqual(len(response.json()['data'].keys()), 1)
response = self.client.get(detail_url,
data={'fields': 'name,description,active'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['data']['name'], 'study1')
self.assertEqual(response.json()['data']['description'],
'description1')
self.assertEqual(len(response.json()['data'].keys()), 3)
def test_update(self):
self.add_admin_credentials()
detail_url = reverse('accessionset-detail',
kwargs={'institute_code': 'ESP004',
'accessionset_number': 'NC001'})
response = self.client.get(detail_url)
accessionset = response.json()
is_public = accessionset['metadata']['is_public']
accessionset['metadata']['is_public'] = not is_public
response = self.client.put(detail_url, data=accessionset, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['metadata']['is_public'], not is_public)
accessionset = response.json()
accessionset['data']['accessions'] = []
response = self.client.put(detail_url, data=accessionset, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
["you are not allowed to change accessionsets's: accessions"])
def test_user_can_not_change_study(self):
self.add_admin_credentials()
response = self.client.get(reverse('observation-list'),
data={'group': 'userGroup',
'is_public': True})
detail_id = response.json()[0]['observation_id']
self.add_user_credentials()
detail_url = reverse('observation-detail',
kwargs={'observation_id': detail_id})
response = self.client.get(detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
api_data = deepcopy(response.json())
api_data['observation_unit'] = 'Plant 1'
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['Can not change observation unit because this is in a study you dont own: study1'])
def test_view_readonly_with_fields(self):
self.add_admin_credentials()
detail_url = reverse('accessionset-detail',
kwargs={'institute_code': 'ESP004',
'accessionset_number': 'NC001'})
response = self.client.get(detail_url, data={'fields': 'institute'})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Passed fields are not allowed'])
response = self.client.get(detail_url,
data={'fields': 'instituteCode'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()['data']['instituteCode'], 'ESP004')
self.assertEqual(len(response.json()['data'].keys()), 1)
response = self.client.get(
detail_url,
data={'fields': 'instituteCode,accessions,genera'})
self.assertEqual(response.json()['data']['instituteCode'], 'ESP004')
self.assertEqual(len(response.json()['data']['accessions']), 2)
self.assertEqual(len(response.json()['data'].keys()), 3)
self.assertEqual(response.json()['data']['genera'], ['Solanum'])
def test_update(self):
self.add_admin_credentials()
list_url = reverse('observation-list')
response = self.client.get(list_url)
api_data = response.json()[0]
detail_url = reverse('observation-detail',
kwargs={'observation_id': api_data['observation_id']})
api_data['observation_unit'] = 'Plant 2'
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
result = response.json()
self.assertEqual(result['observation_id'], api_data['observation_id'])
self.assertEqual(result['value'], api_data['value'])
self.assertEqual(result['observation_unit'], api_data['observation_unit'])
api_data['observation_unit'] = 'non existant'
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['Observation unit non existant does not exist in db'])
def test_create_observation_unit_with_plant(self):
api_data = {
"data": {
"name": "Plant 10",
"accession": {
"instituteCode": "ESP004",
"germplasmNumber": "BGE0001"
},
"level": "plant",
"replicate": "0",
"study": "study3",
"plants": ["Plant 1"]
},
"metadata": {}
}
self.add_user_credentials()
list_url = reverse('observationunit-list')
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['Can not add plant you dont own to observation unit: Plant 1'])
self.add_admin_credentials()
list_url = reverse('observationunit-list')
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
api_data['data']['name'] = 'asa'
api_data['data']['plants'] = ['asa']
list_url = reverse('observationunit-list')
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['The given plant does not exist in asa : asa'])
def test_create(self):
self.add_user_credentials()
list_url = reverse('study-list')
api_data = {
'data': {
'name': 'study9',
'description': 'description9',
'active': True
},
'metadata': {
'group': 'admin',
'is_public': True
}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['can not set group or is public while creating the study'])
api_data = {
'data': {
'name': 'study9',
'description': 'description9',
'active': True
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.json()['metadata'], {
'group': 'userGroup',
'is_public': False
})
def test_create_delete(self):
list_url = reverse('institute-list')
api_data = {'instituteCode': 'ESP005', 'name': 'test genebank'}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.add_admin_credentials()
api_data = {'instituteCode': 'ESP005', 'name': 'test genebank'}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
created_api_data = {
'instituteCode': 'ESP005',
'name': 'test genebank',
'address': None,
'city': None,
'email': None,
'manager': None,
'phone': None,
'type': None,
'url': None,
'zipcode': None,
'collections': None
}
self.docs_are_equal(response.json(), created_api_data)
# Sending corrupt data should fail and return proper error
api_data = {'name': 'test genebank'}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), ['instituteCode mandatory'])
# create existing institute sholud fail and return proper error
with transaction.atomic():
api_data = {'instituteCode': 'ESP005', 'name': 'test genebank'}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['ESP005 already exist in db'])
# test delete
detail_url = reverse('institute-detail', kwargs={'code': 'ESP005'})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# create with all fields
self.add_admin_credentials()
api_data = {
'instituteCode': 'ESP005',
'name': 'test genebank',
'address': "rere",
'city': "csdsds",
'email': "*****@*****.**",
'manager': "manager",
'phone': "1231231231",
'type': "Gobernamental",
'url': 'http://test',
'zipcode': '1121231',
'collections': 'zea'
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.docs_are_equal(response.json(), api_data)
# Regular user operations
# user can retrieve institutes
self.remove_credentials()
self.add_user_credentials()
list_url = reverse('institute-list')
response = self.client.get(list_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
# user can't add new institutes
self.remove_credentials()
self.add_user_credentials()
api_data = {'instituteCode': 'USER000', 'name': 'user genbank'}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# user can't delete institutes
detail_url = reverse('institute-detail', kwargs={'code': 'ESP005'})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_bulk_create(self):
self.add_admin_credentials()
list_url = reverse('accession-list')
api_data = [
{
'data': {
'instituteCode': 'ESP004',
'germplasmNumber': 'BGE0006'
},
'metadata': {
'group': 'userGroup',
'is_public': True
}
},
{
'data': {
'instituteCode': 'ESP004',
'germplasmNumber': 'BGE0007'
},
'metadata': {
'group': 'userGroup',
'is_public': True
}
},
]
response = self.client.post(list_url + 'bulk/',
data=api_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(), [
'can not set group or is public while creating the accession',
'can not set group or is public while creating the accession'
])
# correct data
api_data = [{
'data': {
'instituteCode': 'ESP004',
'germplasmNumber': 'BGE0006'
},
'metadata': {}
}, {
'data': {
'instituteCode': 'ESP004',
'germplasmNumber': 'BGE0007'
},
'metadata': {}
}]
response = self.client.post(list_url + 'bulk/',
data=api_data,
format='json')
assert_error_is_equal(response.json(), ['Successfully added 2 items'])
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(len(self.client.get(list_url).json()), 6)
# Should fail, can not add again same item
api_data = [{
'data': {
'instituteCode': 'ESP004',
'germplasmNumber': 'BGE0006'
},
'metadata': {}
}, {
'data': {
'instituteCode': 'ESP004',
'germplasmNumber': 'BGE0007'
},
'metadata': {}
}]
response = self.client.post(list_url + 'bulk/',
data=api_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(len(response.json()[DETAIL]), 2)
self.assertEqual(len(self.client.get(list_url).json()), 6)
def test_filter(self):
self.add_admin_credentials()
list_url = reverse('observation-list')
response = self.client.get(list_url, data={'value_range_min': '11',
'value_range_max': '13',
'observation_variable': 'Plant size:cm'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 1)
response = self.client.get(list_url, data={'value_range_min': '11',
'observation_variable': 'Plant size:cm'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 1)
response = self.client.get(list_url, data={'value_range_max': '13',
'observation_variable': 'Plant size:cm'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 1)
response = self.client.get(list_url, data={'value_range_max': '13'})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['Can not use value_range filter if not filtered by observation variable'])
response = self.client.get(list_url, data={
'value_range_max': '13',
'observation_variable': 'Plant Growth type:categorical'})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
["Used observation_variable's data type is not numeric"])
response = self.client.get(list_url,
data={'observation_unit': 'Plant 1'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 2)
response = self.client.get(list_url,
data={'observation_unit_contains': 'Plant'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 3)
response = self.client.get(list_url,
data={'group': 'userGroup'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 0)
response = self.client.get(list_url,
data={'group': 'admin'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 3)
response = self.client.get(list_url,
data={'study': 'study1'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 2)
response = self.client.get(list_url,
data={'study': 'Study1'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 2)
response = self.client.get(list_url,
data={'study_contains': 'study'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 3)
response = self.client.get(list_url,
data={'study_contains': 'study1111'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 0)
response = self.client.get(list_url,
data={'accession_number': 'BGE0001'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 2)
response = self.client.get(list_url,
data={'accession_institute': 'ESP004'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()), 2)
def test_create_delete(self):
self.add_admin_credentials()
list_url = reverse('study-list')
api_data = {
'data': {
'name': 'study3',
'description': 'description3'
},
'metadata': {
'group': 'admin',
'is_public': True
}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['can not set group or is public while creating the study'])
api_data = {
'data': {
'name': 'study8',
'description': 'description3'
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.json()['data'], api_data['data'])
api_data = {
'data': {
'name': 'study8',
'description': 'description3'
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['This study already exists in db: study8'])
with transaction.atomic():
api_data = {
'data': {
'name': 'study3',
'description': 'description3'
},
'metadata': {
'group': 'admin',
'is_public': True
}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(
response.json(),
['can not set group or is public while creating the study'])
detail_url = reverse('study-detail', kwargs={'name': 'study3'})
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# acive false
api_data = {
'data': {
'name': 'study9',
'description': 'description3'
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.json()['data'], api_data['data'])
api_data = {
'data': {
'name': 'study99',
'description': 'description3',
'season': 'asads',
'location': 'valencia',
'institution': 'asdas'
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
detail_url = reverse('study-detail', kwargs={'name': 'study99'})
response = self.client.get(detail_url)
# print(response.json())
# full post
api_data = {
'data': {
'name': 'study666',
'description': 'description3',
'season': 'asads',
'location': 'valencia',
'institution': 'asdas',
"start_date": "2017/01/17",
"end_date": "2017/12/01",
"contacts": "Alguien"
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
detail_url = reverse('study-detail', kwargs={'name': 'study666'})
response = self.client.get(detail_url)
# print(response.json())
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# Dates should be valid
api_data = {
'data': {
'name': 'study666',
'description': 'description3',
'season': 'asads',
'location': 'valencia',
'institution': 'asdas',
"start_date": "Ayer",
"end_date": "2017/12/01",
"contacts": "Alguien"
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
api_data = {
'data': {
'name': 'study666',
'description': 'description3',
'season': 'asads',
'location': 'valencia',
'institution': 'asdas',
"start_date": "2017/12/01",
"end_date": "Mañana",
"contacts": "Alguien"
},
'metadata': {}
}
response = self.client.post(list_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_update(self):
self.add_admin_credentials()
detail_url = reverse('study-detail', kwargs={'name': 'study1'})
api_data = {
'data': {
'name': 'study1',
'description': 'description1'
},
'metadata': {
'group': 'admin',
'is_public': False
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
api_data = {
'data': {
'name': 'study1',
'description': 'description1'
},
'metadata': {
'group': 'userGroup',
'is_public': True
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# full data
api_data = {
'data': {
'name': 'study1',
'description': 'description1',
'season': 'asads',
'location': 'valencia',
'institution': 'asdas',
"start_date": "2017/01/17",
"end_date": "2017/12/01",
"contacts": "Alguien"
},
'metadata': {
'group': 'userGroup',
'is_public': True
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), api_data)
# Fail if wrong date format
api_data['data']['start_date'] = 'ayer'
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
api_data['data']['start_date'] = '2017/01/17'
api_data['data']['end_date'] = 'mañana'
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
# Fail changing group if not exists
api_data = {
'data': {
'name': 'study1',
'description': 'description1'
},
'metadata': {
'group': 'rGroup',
'is_public': True
}
}
response = self.client.put(detail_url, data=api_data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
assert_error_is_equal(response.json(),
['Provided group does not exist in db: rGroup'])
