def test_validity_duration_field_to_representation(self): """Test ValidityDurationField.to_representation()""" ga_factory = FakeGreenAssessmentFactory(organization=self.org) green_assessment = ga_factory.get_green_assessment( validity_duration=365) field = ValidityDurationField() result = field.to_representation(green_assessment.validity_duration) self.assertEqual(result, 365)
class TestGreenAssessmentSerializer(TestCase): def setUp(self): self.maxDiff = None user_details = { 'username': '******', 'password': '******', } self.user = User.objects.create_superuser( email='*****@*****.**', **user_details) self.org = Organization.objects.create() OrganizationUser.objects.create(user=self.user, organization=self.org) self.ga_factory = FakeGreenAssessmentFactory(organization=self.org) assessment_data = { 'name': 'Test', 'award_body': 'Test Inc', 'recognition_type': 'AWD', 'description': 'Test Award', 'is_numeric_score': True, 'is_integer_score': True, 'validity_duration': 365 } self.assessment = self.ga_factory.get_green_assessment( **assessment_data ) def tearDown(self): GreenAssessment.objects.all().delete() self.user.delete() self.org.delete() def test_serialization(self): """Test object serialization.""" expected = { 'id': self.assessment.id, 'name': u'Test', 'award_body': u'Test Inc', 'recognition_type': u'AWD', 'recognition_description': u'Award', 'description': u'Test Award', 'is_numeric_score': True, 'is_integer_score': True, 'validity_duration': 365 } result = GreenAssessmentSerializer(self.assessment).data self.assertEqual(expected, result)
class GreenAssessmentTests(DeleteModelsTestCase): """Tests for certification/Green Assessment models and methods""" # pylint: disable=too-many-instance-attributes def setUp(self): self.maxDiff = None user_details = { 'username': '******', 'password': '******', } self.user = User.objects.create_superuser(email='*****@*****.**', **user_details) self.org, _, _ = create_organization(self.user) self.assessment_factory = FakeGreenAssessmentFactory( organization=self.org) self.green_assessment = self.assessment_factory.get_green_assessment( name="Green Test Score", award_body="Green TS Inc", recognition_type=GreenAssessment.SCORE, validity_duration=(365 * 5)) self.url_factory = FakeGreenAssessmentURLFactory() self.gap_factory = FakeGreenAssessmentPropertyFactory( organization=self.org, user=self.user) self.start_date = datetime.date.today() - datetime.timedelta(2 * 365) self.status_date = datetime.date.today() - datetime.timedelta(7) self.target_date = datetime.date.today() - datetime.timedelta(7) self.gap = self.gap_factory.get_green_assessment_property( assessment=self.green_assessment, organization=self.org, user=self.user, with_url=3, metric=5, date=self.start_date, status='Pending', source='Assessor', status_date=self.status_date, version='1', eligibility=True) self.urls = [url.url for url in self.gap.urls.all()] def test_unicode_magic_methods(self): """Test unicode repr methods""" expected = 'Green TS Inc, Green Test Score, Score' self.assertEqual(expected, str(self.green_assessment)) expected = 'Green TS Inc, Green Test Score: 5' self.assertEqual(expected, str(self.gap)) def test_gap_properties(self): """Test properties on GreenAssessmentProperty.""" self.assertEqual('Green Test Score', self.gap.name) self.assertEqual('Green TS Inc', self.gap.body) self.assertEqual('SCR', self.gap.recognition_type) self.assertEqual('Score', self.gap.recognition_description) self.assertEqual(self.start_date.year, self.gap.year) self.assertEqual(self.green_assessment.organization, self.gap.organization) def test_url_properties(self): """Test properties on GreenAssessmentURL.""" url = self.url_factory.get_url(property_assessment=self.gap) expected = self.gap.organization organization = url.organization self.assertEqual(expected, organization) def test_score(self): """Test score/rating/metric properties""" # test score/metric self.assertEqual(5, self.gap.score) self.assertEqual(5, self.gap.metric) self.assertIsInstance(self.gap.metric, int) self.assertIsInstance(self.gap.score, int) self.green_assessment.is_integer_score = False self.assertIsInstance(self.gap.metric, float) self.assertIsInstance(self.gap.score, float) self.gap.score = 4 self.assertEqual(4.0, self.gap.score) with self.assertRaises(ValidationError) as conm: self.gap.rating = '5 stars' exception = conm.exception self.assertEqual("['Green Test Score uses a metric (numeric score)']", str(exception)) self.gap.assessment.is_numeric_score = False self.gap.rating = '5 stars' self.assertEqual('5 stars', self.gap.rating) # must now return rating self.assertEqual('5 stars', self.gap.score) with self.assertRaises(ValidationError) as conm: self.gap.metric = 5 exception = conm.exception self.assertEqual( "['Green Test Score uses a rating (non numeric score)']", str(exception)) def test_expiration(self): """Test expiration_date and is_valid properties""" expected_date = self.start_date + datetime.timedelta(365 * 5) self.assertEqual(expected_date, self.gap.expiration_date) self.assertTrue(self.gap.is_valid) # test setting/retrieving _expiration_date new_expiration = datetime.date.today() + datetime.timedelta(5 * 365) self.gap.expiration_date = new_expiration self.assertEqual(new_expiration, self.gap.expiration_date) self.assertTrue(self.gap.is_valid) # test past expiration date new_expiration = datetime.date.today() - datetime.timedelta(365) self.gap.expiration_date = new_expiration self.assertFalse(self.gap.is_valid) def test_to_bedes(self): """Test to_bedes_dict method.""" expected = { 'Assessment Program': 'Green Test Score', 'Assessment Program Organization': 'Green TS Inc', 'Assessment Recognition Type': 'Score', 'Assessment Recognition Status': 'Pending', 'Assessment Recognition Status Date': self.status_date, 'Assessment Recognition Target Date': None, 'Assessment Value': 5, 'Assessment Version': '1', 'Assessment Year': self.start_date.year, 'Assessment Eligibility': True, 'Assessment Level': None, 'Assessment Program URL': self.urls, } self.assertDictEqual(expected, self.gap.to_bedes_dict()) def test_to_reso(self): """Test to_reso_dict method.""" expected = { 'GreenBuildingVerificationType': 'Green Test Score', 'GreenVerificationBody': 'Green TS Inc', 'GreenVerificationDate': self.start_date, 'GreenVerificationSource': 'Assessor', 'GreenVerificationStatus': 'Pending', 'GreenVerificationMetric': 5, 'GreenVerificationRating': None, 'GreenVerificationVersion': '1', 'GreenVerificationYear': self.start_date.year, 'GreenVerificationURL': self.urls, } self.assertDictEqual(expected, self.gap.to_reso_dict()) def test_to_reso_sub_name(self): """Test to_reso_dict method with substitution.""" expected = { 'GreenBuildingVerificationType': 'Green Test Score', 'GreenVerificationGreenTestScoreBody': 'Green TS Inc', 'GreenVerificationGreenTestScoreDate': self.start_date, 'GreenVerificationGreenTestScoreSource': 'Assessor', 'GreenVerificationGreenTestScoreStatus': 'Pending', 'GreenVerificationGreenTestScoreMetric': 5, 'GreenVerificationGreenTestScoreRating': None, 'GreenVerificationGreenTestScoreVersion': '1', 'GreenVerificationGreenTestScoreYear': self.start_date.year, 'GreenVerificationGreenTestScoreURL': self.urls, } self.assertDictEqual(expected, self.gap.to_reso_dict(sub_name=True))
class TestGreenAssessmentPropertySerializer(DeleteModelsTestCase): def setUp(self): self.maxDiff = None user_details = { 'username': '******', 'password': '******', } self.user = User.objects.create_superuser(email='*****@*****.**', **user_details) self.org, _, _ = create_organization(self.user) self.property_view_factory = FakePropertyViewFactory( organization=self.org, user=self.user) self.ga_factory = FakeGreenAssessmentFactory(organization=self.org) self.gap_factory = FakeGreenAssessmentPropertyFactory( organization=self.org, user=self.user) self.assessment = self.ga_factory.get_green_assessment() self.property_view = self.property_view_factory.get_property_view() self.data = { 'source': 'test', 'status': 'complete', 'status_date': '2017-01-01', 'metric': 5, 'version': '0.1', 'date': '2016-01-01', 'eligibility': True, 'assessment': self.assessment, 'view': self.property_view, } self.urls = ['http://example.com', 'http://example.org'] @mock.patch('seed.serializers.certification.GreenAssessmentURL') def test_create(self, mock_url_model): """Test (overridden) create method.""" serializer = GreenAssessmentPropertySerializer() data = self.data.copy() data['urls'] = self.urls instance = serializer.create(data) mock_url_model.objects.bulk_create.assert_called_with([ mock_url_model(property_assessment=instance, url=url[0], description=url[1]) for url in self.urls ]) @mock.patch('seed.serializers.certification.GreenAssessmentURL') def test_update(self, mock_url_model): """Test (overridden) update method.""" data = self.data.copy() data['urls'] = self.urls[:1] gap = self.gap_factory.get_green_assessment_property(**data) serializer = GreenAssessmentPropertySerializer() data['urls'] = self.urls[1:] instance = serializer.update(gap, data) mock_url_model.objects.filter.assert_called_with( property_assessment=instance) mock_url_model.assert_called_with(url='http://example.org', property_assessment=gap) def test_validate(self): """Test (overriden) validate method""" serializer = GreenAssessmentPropertySerializer() # add context mock_request = mock.MagicMock() mock_request.user = self.user serializer.context = {'request': mock_request} # assert raises error if rating and metric supplied data = self.data.copy() data['rating'] = 'Gold Star' with self.assertRaises(ValidationError) as conm: serializer.validate(data) exception = conm.exception expected = "['Only one of metric or rating can be supplied.']" self.assertEqual(expected, str(exception)) # assert raises error if metric is expected del data['metric'] data['rating'] = '5' with self.assertRaises(ValidationError) as conm: serializer.validate(data) exception = conm.exception expected = "['{} uses a metric (numeric score).']".format( self.assessment.name) self.assertEqual(expected, str(exception)) # assert raises error if metric is of wrong type del data['rating'] data['metric'] = '5 stars' with self.assertRaises(ValidationError) as conm: serializer.validate(data) exception = conm.exception expected = "['Metric must be a number.']" self.assertEqual(expected, str(exception)) # assert raises error if rating expected self.assessment.is_numeric_score = False data['metric'] = 5 with self.assertRaises(ValidationError) as conm: serializer.validate(data) exception = conm.exception expected = "['{} uses a rating (non-numeric score).']".format( self.assessment.name) # assert raises error if rating is of wrong type del data['metric'] data['rating'] = 5 with self.assertRaises(ValidationError) as conm: serializer.validate(data) exception = conm.exception expected = "['Rating must be a string.']" self.assertEqual(expected, str(exception)) # assert converts ints to floats self.assessment.is_numeric_score = True del data['rating'] data['metric'] = 5 result = serializer.validate(data) self.assertEqual(result, data) # assert raises error if integer expected data['metric'] = 3.5 with self.assertRaises(ValidationError) as conm: serializer.validate(data) exception = conm.exception expected = "['Metric must be an integer.']" self.assertEqual(expected, str(exception)) # assert raises error if assessment missing del data['assessment'] with self.assertRaises(ValidationError) as conm: serializer.validate(data) exception = conm.exception expected = "['Could not find assessment.']" self.assertEqual(expected, str(exception))
class TestPropertySerializers(DeleteModelsTestCase): def setUp(self): self.maxDiff = None user_details = { 'username': '******', 'password': '******', } self.user = User.objects.create_superuser(email='*****@*****.**', **user_details) self.org, _, _ = create_organization(self.user) self.audit_log_factory = FakePropertyAuditLogFactory( organization=self.org, user=self.user) self.property_factory = FakePropertyFactory(organization=self.org) self.property_state_factory = FakePropertyStateFactory( organization=self.org) self.property_view_factory = FakePropertyViewFactory( organization=self.org, user=self.user) self.ga_factory = FakeGreenAssessmentFactory(organization=self.org) self.gap_factory = FakeGreenAssessmentPropertyFactory( organization=self.org, user=self.user) self.label_factory = FakeStatusLabelFactory(organization=self.org) self.assessment = self.ga_factory.get_green_assessment() self.property_view = self.property_view_factory.get_property_view() self.gap_data = { 'source': 'test', 'status': 'complete', 'status_date': datetime.date(2017, 0o1, 0o1), 'metric': 5, 'version': '0.1', 'date': datetime.date(2016, 0o1, 0o1), 'eligibility': True, 'assessment': self.assessment, 'view': self.property_view, } self.urls = ['http://example.com', 'http://example.org'] def test_audit_log_serializer(self): """Test to_representation method.""" # test with AUDIT_USER_CREATE audit_log = self.audit_log_factory.get_property_audit_log() result = PropertyAuditLogReadOnlySerializer(audit_log).data self.assertEqual(result['description'], 'test audit log') self.assertEqual(result['date_edited'], audit_log.created.ctime()) self.assertEqual(result['source'], 'UserCreate') self.assertIsNone(result['changed_fields']) self.assertEqual(result['state']['city'], 'Boring') # test with AUDIT_USER_EDIT changed_fields = ['a', 'b', 'c'] audit_log = self.audit_log_factory.get_property_audit_log( record_type=AUDIT_USER_EDIT, description=json.dumps(changed_fields)) result = PropertyAuditLogReadOnlySerializer(audit_log).data self.assertEqual(result['description'], 'User edit') self.assertEqual(result['source'], 'UserEdit') self.assertEqual(result['changed_fields'], changed_fields) def test_property_view_list_serializer(self): """Test to_representation method.""" property_view_1 = self.property_view_factory.get_property_view() property_view_2 = self.property_view_factory.get_property_view() gap1_data = self.gap_data.copy() gap2_data = self.gap_data.copy() gap1_data['view'] = property_view_1 gap2_data['view'] = property_view_2 gap2_data['metric'] = 4 self.gap_factory.get_green_assessment_property(**gap1_data) self.gap_factory.get_green_assessment_property(**gap2_data) serializer = PropertyViewListSerializer(child=PropertyViewSerializer()) result = serializer.to_representation( [property_view_1, property_view_2]) self.assertEqual(result[0]['cycle']['id'], property_view_1.cycle_id) self.assertEqual(result[1]['cycle']['id'], property_view_2.cycle_id) self.assertEqual(result[0]['state']['id'], property_view_1.state_id) self.assertEqual(result[1]['state']['id'], property_view_2.state_id) self.assertEqual(result[0]['certifications'][0]['score'], 5) self.assertEqual(result[1]['certifications'][0]['score'], 4) self.assertEqual(result[0]['certifications'][0]['assessment']['name'], self.assessment.name) self.assertEqual(result[1]['certifications'][0]['assessment']['name'], self.assessment.name) # with queryset serializer = PropertyViewListSerializer(child=PropertyViewSerializer()) queryset = PropertyView.objects.filter( id__in=[property_view_1.id, property_view_2.id]).order_by('id') result = serializer.to_representation(queryset) self.assertEqual(result[0]['cycle']['id'], property_view_1.cycle_id) self.assertEqual(result[1]['cycle']['id'], property_view_2.cycle_id) self.assertEqual(result[0]['state']['id'], property_view_1.state_id) self.assertEqual(result[1]['state']['id'], property_view_2.state_id) self.assertEqual(result[0]['certifications'][0]['score'], 5) self.assertEqual(result[1]['certifications'][0]['score'], 4) self.assertEqual(result[0]['certifications'][0]['assessment']['name'], self.assessment.name) self.assertEqual(result[1]['certifications'][0]['assessment']['name'], self.assessment.name) def test_property_list_serializer(self): """Test PropertyListSerializer.to_representation""" # TODO test to representation property1 = self.property_factory.get_property() property2 = self.property_factory.get_property() expected = [ OrderedDict([ ('id', property1.id), ('campus', False), ('parent_property', None), ]), OrderedDict([ ('id', property2.id), ('campus', False), ('parent_property', None), ]), ] serializer = PropertyListSerializer(child=PropertyMinimalSerializer()) result = serializer.to_representation([property1, property2]) self.assertEqual(expected, result)
class TestPropertyViewAsStateSerializers(DeleteModelsTestCase): def setUp(self): self.maxDiff = None user_details = { 'username': '******', 'password': '******', } self.user = User.objects.create_superuser(email='*****@*****.**', **user_details) self.org, _, _ = create_organization(self.user) self.audit_log_factory = FakePropertyAuditLogFactory( organization=self.org, user=self.user) self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user) self.property_state_factory = FakePropertyStateFactory( organization=self.org) self.property_view_factory = FakePropertyViewFactory( organization=self.org, user=self.user) self.ga_factory = FakeGreenAssessmentFactory(organization=self.org) self.gap_factory = FakeGreenAssessmentPropertyFactory( organization=self.org, user=self.user) self.taxlot_property_factory = FakeTaxLotPropertyFactory( organization=self.org, user=self.user) self.taxlot_state_factory = FakeTaxLotStateFactory( organization=self.org) self.taxlot_view_factory = FakeTaxLotViewFactory(organization=self.org, user=self.user) self.assessment = self.ga_factory.get_green_assessment() self.cycle = self.cycle_factory.get_cycle() self.property_state = self.property_state_factory.get_property_state() self.property_view = self.property_view_factory.get_property_view( state=self.property_state, cycle=self.cycle) self.taxlot_state = self.taxlot_state_factory.get_taxlot_state() self.taxlot_view = self.taxlot_view_factory.get_taxlot_view( state=self.taxlot_state, cycle=self.cycle) self.audit_log = self.audit_log_factory.get_property_audit_log( state=self.property_state, view=self.property_view, record_type=AUDIT_USER_EDIT, description=json.dumps(['a', 'b'])) self.audit_log2 = self.audit_log_factory.get_property_audit_log( view=self.property_view) self.gap_data = { 'source': 'test', 'status': 'complete', 'status_date': datetime.date(2017, 0o1, 0o1), 'metric': 5, 'version': '0.1', 'date': datetime.date(2016, 0o1, 0o1), 'eligibility': True, 'assessment': self.assessment, 'view': self.property_view, } self.urls = ['http://example.com', 'http://example.org'] self.gap = self.gap_factory.get_green_assessment_property( **self.gap_data) self.serializer = PropertyViewAsStateSerializer( instance=self.property_view) def test_init(self): """Test __init__.""" expected = PropertyAuditLogReadOnlySerializer(self.audit_log).data # for now convert the site_eui to a magnitude to get the test to pass # this really needs to be at another level data = self.serializer.current # data['state']['site_eui'] = data['state']['site_eui'].magnitude self.assertEqual(data, expected) def test_get_certifications(self): """Test get_certifications""" expected = [GreenAssessmentPropertyReadOnlySerializer(self.gap).data] self.assertEqual( self.serializer.get_certifications(self.property_view), expected) def test_get_changed_fields(self): """Test get_changed_fields""" expected = ['a', 'b'] self.assertEqual(self.serializer.get_changed_fields(None), expected) def test_get_date_edited(self): """Test get_date_edited""" expected = self.audit_log.created.ctime() self.assertEqual(self.serializer.get_date_edited(None), expected) def test_get_filename(self): """Test get_filename""" expected = self.audit_log.import_filename self.assertEqual(self.serializer.get_filename(None), expected) def test_get_history(self): """Test get_history""" obj = mock.MagicMock() obj.state = self.property_state data = self.serializer.get_history(obj) # Really need to figure out how to get the serializer to save the magnitude correctly. # data[0]['state']['site_eui'] = data[0]['state']['site_eui'].magnitude expected = [PropertyAuditLogReadOnlySerializer(self.audit_log2).data] self.assertEqual(data, expected) def test_get_state(self): obj = mock.MagicMock() obj.state = self.property_state def test_get_source(self): """Test get_source""" expected = self.audit_log.get_record_type_display() self.assertEqual(self.serializer.get_source(None), expected) def test_get_taxlots(self): """Test get_taxlots""" self.taxlot_property_factory.get_taxlot_property( cycle=self.cycle, property_view=self.property_view, taxlot_view=self.taxlot_view) result = self.serializer.get_taxlots(self.property_view) self.assertEqual(result[0]['state']['id'], self.taxlot_state.id) @mock.patch('seed.serializers.properties.PropertyView') @mock.patch('seed.serializers.properties.PropertyStateWritableSerializer') def test_create(self, mock_serializer, mock_pview): """Test create""" mock_serializer.return_value.is_valid.return_value = True mock_serializer.return_value.save.return_value = self.property_state mock_pview.objects.create.return_value = self.property_view data = {'org_id': 1, 'cycle': 2, 'state': {'test': 3}, 'property': 4} serializer = PropertyViewAsStateSerializer() serializer.create(data) mock_serializer.assert_called_with(data={'test': 3}) self.assertTrue(mock_serializer.return_value.save.called) mock_pview.objects.create.assert_called_with(state=self.property_state, cycle_id=2, property_id=4, org_id=1) @mock.patch('seed.serializers.properties.PropertyStateWritableSerializer') def test_update_put(self, mock_serializer): """Test update with PUT""" mock_serializer.return_value.is_valid.return_value = True mock_serializer.return_value.save.return_value = self.property_state mock_request = mock.MagicMock() data = {'org_id': 1, 'cycle': 2, 'state': {'test': 3}, 'property': 4} serializer = PropertyViewAsStateSerializer( context={'request': mock_request}) mock_request.METHOD = 'PUT' serializer.update(self.property_view, data) mock_serializer.assert_called_with(data={'test': 3}) self.assertTrue(mock_serializer.return_value.save.called) @mock.patch('seed.serializers.properties.PropertyStateWritableSerializer') def test_update_patch(self, mock_serializer): """Test update with PATCH""" mock_serializer.return_value.is_valid.return_value = True mock_serializer.return_value.save.return_value = self.property_state mock_request = mock.MagicMock() mock_request.method = 'PATCH' data = {'org_id': 1, 'cycle': 2, 'state': {'test': 3}, 'property': 4} serializer = PropertyViewAsStateSerializer( context={'request': mock_request}) serializer.update(self.property_view, data) mock_serializer.assert_called_with(self.property_state, data={'test': 3}) self.assertTrue(mock_serializer.return_value.save.called)