def test_search_measurement3(self):
"""
Should return one measurement that matches the rating, assessment combo.
One measurement relates to an assessment that is not in the scope of the search.
"""
template1 = TemplateFactory()
template2 = TemplateFactory()
attribute1 = AttributeFactory(template=template1)
attribute2 = AttributeFactory(template=template2)
rating = RatingFactory(attribute=attribute1)
assessment1 = AssessmentFactory(template=template1)
assessment2 = AssessmentFactory(template=template2)
measurement1 = MeasurementFactory(assessment=assessment1,
attribute=attribute1,
rating=rating)
measurement2 = MeasurementFactory(assessment=assessment2,
attribute=attribute2,
rating=rating)
url = "%s?assessment__id=%s&rating__attribute=%s" % (
reverse('measurement-list'), assessment1.id, attribute1.id)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0]['id'], measurement1.id)
self.assertEqual(response.data[0]['rating'], rating.id)
self.assertEqual(len(response.data), 1)
def test_creation_of_assessment(self):
template = TemplateFactory()
team = TeamFactory()
assessment = AssessmentFactory(template=template, team=team)
assessment.clean()
self.assertEqual(
"%s - %s - %d" % (team.name, template.name, assessment.id),
str(assessment))
def test_list_assessment_count(self):
"""
Ensure multiple assessments are returned in a list
and sorted by last first
"""
assessment1 = AssessmentFactory()
assessment2 = AssessmentFactory()
url = reverse('assessment-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), Assessment.objects.count())
self.assertEqual(response.data[0]['id'], assessment2.id)
self.assertEqual(response.data[1]['id'], assessment1.id)
def test_update_target_rating_to_measurement(self):
"""
Ensure we can update an existing measurement object with a target rating
"""
assessment = AssessmentFactory()
rating = RatingFactory()
target_rating = RatingFactory(attribute=rating.attribute)
measurement = MeasurementFactory(assessment=assessment,
attribute=rating.attribute,
rating=rating)
url = reverse('measurement-detail', args=(measurement.id, ))
data = {
"id": measurement.id,
"assessment": assessment.id,
"attribute": rating.attribute.id,
"rating": rating.id,
"target_rating": target_rating.id,
"observations": "123",
"action": "456"
}
response = self.client.put(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Measurement.objects.count(), 1)
self.assertEqual(response.data['id'], measurement.id)
self.assertEqual(response.data['target_rating'], target_rating.id)
def test_create_measurement_success_assessment_read_only_super_user(self):
"""
Ensure we can create a new measurement when the assessment is read only and superuser
"""
password = '******'
my_admin = User.objects.create_superuser('myuser', '*****@*****.**',
password)
self.client.login(username=my_admin.username, password=password)
assessment = AssessmentFactory(status="DONE")
rating = RatingFactory()
url = reverse('measurement-list')
data = {
"id": None,
"assessment": assessment.id,
"attribute": rating.attribute.id,
"rating": rating.id,
"observations": None,
"action": "456"
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Measurement.objects.count(), 1)
def test_list_assessment(self):
"""
List all assessments and check that all fields are returned
"""
assessment1 = AssessmentFactory()
url = reverse('assessment-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0]['id'], assessment1.id)
self.assertEqual(response.data[0]['template']['name'],
assessment1.template.name)
self.assertEqual(response.data[0]['template']['id'],
assessment1.template.id)
self.assertEqual(response.data[0]['team']['name'],
assessment1.team.name)
self.assertEqual(response.data[0]['team']['id'], assessment1.team.id)
self.assertEqual(
datetime.datetime.strptime(response.data[0]['created'],
'%Y-%m-%dT%H:%M:%S.%fZ'),
assessment1.created.replace(tzinfo=None))
self.assertEqual(
datetime.datetime.strptime(response.data[0]['updated'],
'%Y-%m-%dT%H:%M:%S.%fZ'),
assessment1.updated.replace(tzinfo=None))
def test_can_delete_measurement_when_assessment_is_read_only_and_super_user(
self):
"""
Ensure we can delete an existing measurement object when assessment is read only and you are superuser
"""
assessment = AssessmentFactory(status="DONE")
rating = RatingFactory()
target_rating = RatingFactory(attribute=rating.attribute)
measurement = MeasurementFactory(assessment=assessment,
attribute=rating.attribute,
rating=rating)
password = '******'
my_admin = User.objects.create_superuser('myuser', '*****@*****.**',
password)
self.client.login(username=my_admin.username, password=password)
url = reverse('measurement-detail', args=(measurement.id, ))
data = {
"id": measurement.id,
"assessment": assessment.id,
"attribute": rating.attribute.id,
"rating": rating.id,
"target_rating": target_rating.id,
"observations": "123",
"action": "456"
}
response = self.client.delete(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Measurement.objects.count(), 0)
def test_halt_updates_if_read_only_non_super_user(self):
"""
Ensure you can't update the assessment if you're not a superadmin and status is done.
"""
assessment = AssessmentFactory(status="DONE")
url = reverse('assessment-detail', args=(assessment.id,))
data = {"id": assessment.id, "template": assessment.template.id, "status": "TODO", "tags": []}
response = self.client.put(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(Assessment.objects.count(), 1)
def test_update_status_to_done(self):
"""
Ensure even anonymous users can make an assessment done.
"""
assessment = AssessmentFactory()
url = reverse('assessment-detail', args=(assessment.id,))
data = {"id": assessment.id, "template": assessment.template.id, "status": "DONE", "tags": []}
response = self.client.put(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Assessment.objects.count(), 1)
self.assertEqual(Assessment.objects.get(pk=assessment.id).status, "DONE")
def test_search_measurement2(self):
"""
Should return zero measurements as the api search is for a different assessment
"""
template = TemplateFactory()
attribute = AttributeFactory(template=template)
rating_in_scope1 = RatingFactory(attribute=attribute)
rating_in_scope2 = RatingFactory(attribute=attribute)
assessment1 = AssessmentFactory(template=template)
assessment2 = AssessmentFactory(template=template)
assessment3 = AssessmentFactory()
measurement1 = MeasurementFactory(assessment=assessment1,
attribute=attribute,
rating=rating_in_scope1)
measurement2 = MeasurementFactory(assessment=assessment2,
attribute=attribute,
rating=rating_in_scope2)
url = "%s?assessment__id=%s&rating__attribute=%s" % (
reverse('measurement-list'), assessment3.id, attribute.id)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
def test_do_not_halt_deletes_if_read_only_super_user(self):
"""
Ensure you can delete the assessment if you are a superadmin and status is done.
"""
assessment = AssessmentFactory(status="DONE")
password = '******'
my_admin = User.objects.create_superuser('myuser', '*****@*****.**', password)
self.client.login(username=my_admin.username, password=password)
url = reverse('assessment-detail', args=(assessment.id,))
data = {"id": assessment.id, "template": assessment.template.id, "status": "TODO", "tags": []}
response = self.client.delete(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Assessment.objects.count(), 0)
def test_creation_of_measurement_no_target(self):
"""
Should be able to create a measurement without a target_rating
"""
template = TemplateFactory()
attribute = AttributeFactory(template=template)
assessment = AssessmentFactory(template=template)
rating = RatingFactory(attribute=attribute)
measurement = MeasurementFactory(assessment=assessment,
attribute=attribute,
rating=rating)
measurement.clean()
self.assertEqual(1, Measurement.objects.count())
self.assertEqual(
"%s - %s - %s" % (str(assessment), attribute.name, rating.name),
str(measurement))
def test_update_tags(self):
"""
Ensure you can update the tags
"""
tag1 = TagFactory()
tag2 = TagFactory()
assessment = AssessmentFactory(tags=[tag1, tag2])
tag3 = TagFactory()
url = reverse('assessment-detail', args=(assessment.id,))
data = {"id": assessment.id, "template": assessment.template.id, "status": assessment.status,
"tags": [tag1.id, tag3.id]}
response = self.client.put(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['id'], data['id'])
self.assertEqual(len(response.data['tags']), 2)
self.assertCountEqual(response.data['tags'], [tag1.id, tag3.id])
def test_create_measurement_fail_assessment_read_only(self):
"""
Ensure we cannot create a new measurement when the assessment is read only
"""
assessment = AssessmentFactory(status="DONE")
rating = RatingFactory()
url = reverse('measurement-list')
data = {
"id": None,
"assessment": assessment.id,
"attribute": rating.attribute.id,
"rating": rating.id,
"observations": None,
"action": "456"
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(Measurement.objects.count(), 0)
def test_create_measurement_no_action(self):
"""
Ensure we can create a new measurement object without an action.
"""
assessment = AssessmentFactory()
rating = RatingFactory()
url = reverse('measurement-list')
data = {
"id": None,
"assessment": assessment.id,
"attribute": rating.attribute.id,
"rating": rating.id,
"observations": "123",
"action": None
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Measurement.objects.count(), 1)
def test_creation_of_measurement(self):
"""
Create a measurement with all fields specified
"""
template = TemplateFactory()
attribute = AttributeFactory(template=template)
rating = RatingFactory(attribute=attribute)
target_rating = RatingFactory(attribute=attribute)
assessment = AssessmentFactory(template=template)
measurement = MeasurementFactory(assessment=assessment,
attribute=attribute,
rating=rating,
target_rating=target_rating)
measurement.clean()
self.assertEqual(1, Measurement.objects.count())
self.assertEqual(
"%s - %s - %s" % (str(assessment), attribute.name, rating.name),
str(measurement))
def test_create_measurement_no_rating(self):
"""
Ensure we can't create a new measurement object without a rating.
"""
assessment = AssessmentFactory()
target_rating = RatingFactory()
url = reverse('measurement-list')
data = {
"id": None,
"assessment": assessment.id,
"attribute": target_rating.attribute.id,
"rating": None,
"target_rating": target_rating.id,
"observations": "123",
"action": "456"
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(Measurement.objects.count(), 0)
def test_cannot_update_measurement_when_assessment_is_read_only(self):
"""
Ensure we cannot update an existing measurement object when assessment is read only
"""
assessment = AssessmentFactory(status="DONE")
rating = RatingFactory()
target_rating = RatingFactory(attribute=rating.attribute)
measurement = MeasurementFactory(assessment=assessment,
attribute=rating.attribute,
rating=rating)
url = reverse('measurement-detail', args=(measurement.id, ))
data = {
"id": measurement.id,
"assessment": assessment.id,
"attribute": rating.attribute.id,
"rating": rating.id,
"target_rating": target_rating.id,
"observations": "123",
"action": "456"
}
response = self.client.put(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_fail_measurement_with_rating_from_different_template(self):
"""
Don't create measurements referring to rating from a different template than the assessment
"""
template1 = TemplateFactory()
attribute1 = AttributeFactory(template=template1)
rating1 = RatingFactory(attribute=attribute1)
assessment = AssessmentFactory(template=template1)
template2 = TemplateFactory()
attribute2 = AttributeFactory(template=template2)
rating2 = RatingFactory(attribute=attribute2)
measurement1 = MeasurementFactory(assessment=assessment,
attribute=attribute1,
rating=rating2)
self.assertRaises(ValidationError, measurement1.clean)
measurement2 = MeasurementFactory(assessment=assessment,
attribute=attribute2,
rating=rating1,
target_rating=rating2)
self.assertRaises(ValidationError, measurement2.clean)
def test_ordering_of_assessments(self):
assessment1 = AssessmentFactory()
assessment2 = AssessmentFactory()
self.assertEqual(assessment2, Assessment.objects.first())
