def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
self.client.login(**user_details)
self.state_1 = self.property_state_factory.get_property_state(
address_line_1='1 property state',
pm_property_id='5766973' # this allows the Property to be targetted for PM meter additions
)
self.property_1 = self.property_factory.get_property()
self.view_1 = PropertyView.objects.create(
property=self.property_1, cycle=self.cycle, state=self.state_1
)
self.state_2 = self.property_state_factory.get_property_state(address_line_1='2 property state')
self.property_2 = self.property_factory.get_property()
self.view_2 = PropertyView.objects.create(
property=self.property_2, cycle=self.cycle, state=self.state_2
)
self.import_record = ImportRecord.objects.create(owner=self.user, last_modified_by=self.user, super_organization=self.org)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, _, _ = create_organization(self.user)
self.status_label = StatusLabel.objects.create(
name='test', super_organization=self.org
)
self.column_factory = FakeColumnFactory(organization=self.org)
self.cycle_factory = FakeCycleFactory(organization=self.org,
user=self.user)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone())
)
self.default_bsync_profile = ColumnMappingProfile.objects.get(profile_type=ColumnMappingProfile.BUILDINGSYNC_DEFAULT)
self.client.login(**user_details)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
user_details_2 = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.user_2 = User.objects.create_superuser(**user_details_2)
self.org, _, _ = create_organization(self.user, "test-organization-a")
self.org_2, _, _ = create_organization(self.user_2,
"test-organization-b")
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
self.tax_lot_state_factory = FakeTaxLotStateFactory(
organization=self.org)
Column.objects.create(column_name='test', organization=self.org)
Column.objects.create(column_name='extra_data_test',
table_name='PropertyState',
organization=self.org,
is_extra_data=True)
self.cross_org_column = Column.objects.create(
column_name='extra_data_test',
table_name='PropertyState',
organization=self.org_2,
is_extra_data=True)
self.client.login(**user_details)
def setUp(self):
selfvars = self.set_up(ASSESSED_RAW)
self.user, self.org, self.import_file, self.import_record, self.cycle = selfvars
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(
organization=self.org)
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.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 setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
self.client.login(**user_details)
self.state_1 = self.property_state_factory.get_property_state(
address_line_1='1 property state',
pm_property_id='5766973' # this allows the Property to be targetted for PM meter additions
)
self.property_1 = self.property_factory.get_property()
PropertyView.objects.create(
property=self.property_1, cycle=self.cycle, state=self.state_1
)
self.state_2 = self.property_state_factory.get_property_state(address_line_1='2 property state')
self.property_2 = self.property_factory.get_property()
PropertyView.objects.create(
property=self.property_2, cycle=self.cycle, state=self.state_2
)
self.import_record = ImportRecord.objects.create(owner=self.user, last_modified_by=self.user, super_organization=self.org)
# Give 2 meters to one of the properties
gb_filename = "example-GreenButton-data.xml"
filepath = os.path.dirname(os.path.abspath(__file__)) + "/data/" + gb_filename
gb_import_file = ImportFile.objects.create(
import_record=self.import_record,
source_type="GreenButton",
uploaded_filename=gb_filename,
file=SimpleUploadedFile(name=gb_filename, content=open(filepath, 'rb').read()),
cycle=self.cycle,
matching_results_data={"property_id": self.property_1.id} # this is how target property is specified
)
gb_import_url = reverse("api:v2:import_files-save-raw-data", args=[gb_import_file.id])
gb_import_post_params = {
'cycle_id': self.cycle.pk,
'organization_id': self.org.pk,
}
self.client.post(gb_import_url, gb_import_post_params)
# Merge the properties
url = reverse('api:v2:properties-merge') + '?organization_id={}'.format(self.org.pk)
post_params = json.dumps({
'state_ids': [self.state_2.pk, self.state_1.pk] # priority given to state_1
})
self.client.post(url, post_params, content_type='application/json')
def setUp(self):
self.user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **self.user_details
)
self.org, _, _ = create_organization(self.user)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
class InventoryViewTests(DeleteModelsTestCase):
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, _, _ = create_organization(self.user)
self.status_label = StatusLabel.objects.create(
name='test', super_organization=self.org
)
self.column_factory = FakeColumnFactory(organization=self.org)
self.cycle_factory = FakeCycleFactory(organization=self.org,
user=self.user)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone())
)
self.client.login(**user_details)
def test_get_building_sync(self):
state = self.property_state_factory.get_property_state()
prprty = self.property_factory.get_property()
pv = PropertyView.objects.create(
property=prprty, cycle=self.cycle, state=state
)
# go to buildingsync endpoint
params = {
'organization_id': self.org.pk
}
url = reverse('api:v2.1:properties-building-sync', args=[pv.id])
response = self.client.get(url, params)
self.assertIn('<auc:FloorAreaValue>%s.0</auc:FloorAreaValue>' % state.gross_floor_area, response.content)
def test_get_hpxml(self):
state = self.property_state_factory.get_property_state()
prprty = self.property_factory.get_property()
pv = PropertyView.objects.create(
property=prprty, cycle=self.cycle, state=state
)
# go to buildingsync endpoint
params = {
'organization_id': self.org.pk
}
url = reverse('api:v2.1:properties-hpxml', args=[pv.id])
response = self.client.get(url, params)
self.assertIn('<GrossFloorArea>%s.0</GrossFloorArea>' % state.gross_floor_area, response.content)
def setUp(self):
selfvars = self.set_up(ASSESSED_RAW)
self.user, self.org, self.import_file_1, self.import_record, self.cycle = selfvars
user_details = {
'username': '******',
'password': '******',
}
self.client.login(**user_details)
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
class WktTests(TestCase):
def setUp(self):
self.user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **self.user_details
)
self.org, _, _ = create_organization(self.user)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
def test_long_lat_wkt_takes_a_state_and_returns_the_WKT_string_or_None(self):
property_details = self.property_state_factory.get_details()
property_details['organization_id'] = self.org.id
no_long_lat_property = PropertyState(**property_details)
no_long_lat_property.save()
property_details['long_lat'] = 'POINT (-104.985765 39.764984)'
geocoded_property = PropertyState(**property_details)
geocoded_property.save()
no_long_lat_record = PropertyState.objects.get(pk=no_long_lat_property.id)
geocoded_record = PropertyState.objects.get(pk=geocoded_property.id)
self.assertIsNone(no_long_lat_record.long_lat)
self.assertIsNone(long_lat_wkt(no_long_lat_record))
self.assertIsInstance(geocoded_record.long_lat, Point)
self.assertEqual('POINT (-104.985765 39.764984)', long_lat_wkt(geocoded_property))
def test_bounding_box_wkt_takes_a_state_and_returns_the_WKT_string_or_None(self):
property_details = self.property_state_factory.get_details()
property_details['organization_id'] = self.org.id
no_bounding_box_property = PropertyState(**property_details)
no_bounding_box_property.save()
property_details['bounding_box'] = 'POLYGON ((0 0, 4 0, 4 4, 0 4, 0 0))'
bounding_box_property = PropertyState(**property_details)
bounding_box_property.save()
no_bounding_box_record = PropertyState.objects.get(pk=no_bounding_box_property.id)
geocoded_record = PropertyState.objects.get(pk=bounding_box_property.id)
self.assertIsNone(no_bounding_box_record.bounding_box)
self.assertIsNone(bounding_box_wkt(no_bounding_box_record))
self.assertIsInstance(geocoded_record.bounding_box, Polygon)
self.assertEqual('POLYGON ((0 0, 4 0, 4 4, 0 4, 0 0))', bounding_box_wkt(bounding_box_property))
def setUp(self):
selfvars = self.set_up(ASSESSED_RAW)
self.user, self.org, self.import_file_1, self.import_record_1, self.cycle_1 = selfvars
cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.cycle_2 = cycle_factory.get_cycle(name="Cycle 2")
self.import_record_2, self.import_file_2 = self.create_import_file(
self.user, self.org, self.cycle_2)
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(
organization=self.org)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **user_details
)
self.org, _, _ = create_organization(self.user)
self.org.mapquest_api_key = test_key
self.org.save()
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.tax_lot_state_factory = FakeTaxLotStateFactory(organization=self.org)
def test_meters_and_readings_are_associated_to_every_record_across_all_cycles_with_a_given_pm_property_id(
self):
# new, in-cycle state NOT associated to existing record but has same PM Property ID
property_details_1 = FakePropertyStateFactory(
organization=self.org).get_details()
property_details_1['organization_id'] = self.org.id
property_details_1['pm_property_id'] = self.state_1.pm_property_id
property_details_1['custom_id_1'] = "values that forces non-match"
new_property_1 = PropertyState(**property_details_1)
new_property_1.save()
property_3 = self.property_factory.get_property()
PropertyView.objects.create(property=property_3,
cycle=self.cycle,
state=new_property_1)
# new, out-cycle state NOT associated to existing record but has same PM Property ID
property_details_2 = FakePropertyStateFactory(
organization=self.org).get_details()
property_details_2['organization_id'] = self.org.id
property_details_2['pm_property_id'] = self.state_1.pm_property_id
property_details_2[
'custom_id_1'] = "second value that forces non-match"
new_property_2 = PropertyState(**property_details_2)
new_property_2.save()
new_cycle = self.cycle_factory.get_cycle(
start=datetime(2011, 10, 10, tzinfo=get_current_timezone()))
property_4 = self.property_factory.get_property()
PropertyView.objects.create(property=property_4,
cycle=new_cycle,
state=new_property_2)
url = reverse("api:v3:import_files-start-save-data",
args=[self.import_file.id])
url += f'?organization_id={self.org.pk}'
post_params = {
'cycle_id': self.cycle.pk,
}
self.client.post(url, post_params)
refreshed_property_1 = Property.objects.get(pk=self.property_1.id)
self.assertEqual(refreshed_property_1.meters.all().count(), 2)
refreshed_property_3 = Property.objects.get(pk=property_3.id)
self.assertEqual(refreshed_property_3.meters.all().count(), 2)
refreshed_property_4 = Property.objects.get(pk=property_4.id)
self.assertEqual(refreshed_property_4.meters.all().count(), 2)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **user_details
)
self.org, _, _ = create_organization(self.user)
self.client.login(**user_details)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.tax_lot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.property_view_factory = FakePropertyViewFactory(organization=self.org)
self.taxlot_view_factory = FakeTaxLotViewFactory(organization=self.org)
def setUp(self):
self.api_view = UpdateInventoryLabelsAPIView()
# Models can't be imported directly hence self
self.PropertyViewLabels = self.api_view.models['property']
self.TaxlotViewLabels = self.api_view.models['taxlot']
self.user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**self.user_details)
self.org, _, _ = create_organization(self.user)
self.status_label = Label.objects.create(
name='test', super_organization=self.org
)
self.status_label_2 = Label.objects.create(
name='test_2', super_organization=self.org
)
self.client.login(**self.user_details)
self.label_1 = Label.objects.all()[0]
self.label_2 = Label.objects.all()[1]
self.label_3 = Label.objects.all()[2]
self.label_4 = Label.objects.all()[3]
# Create some real PropertyViews, Properties, PropertyStates, and StatusLabels since validations happen
cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
cycle = cycle_factory.get_cycle(start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone()))
property_state_factory = FakePropertyStateFactory(organization=self.org)
for i in range(1, 11):
ps = property_state_factory.get_property_state()
p = Property.objects.create(organization=self.org)
PropertyView.objects.create(
cycle=cycle,
state=ps,
property=p
)
self.propertyview_ids = PropertyView.objects.all().order_by('id').values_list('id', flat=True)
self.mock_propertyview_label_qs = mock_queryset_factory(
self.PropertyViewLabels,
flatten=True,
propertyview_id=self.propertyview_ids,
statuslabel_id=[self.label_1.id] * 3 + [self.label_2.id] * 3 + [self.label_3.id] * 2 + [self.label_4.id] * 2
)
def setUp(self):
self.user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(email='*****@*****.**',
**self.user_details)
self.org, _, _ = create_organization(self.user)
self.client.login(**self.user_details)
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
property_details = self.property_state_factory.get_details()
property_details['organization_id'] = self.org.id
state_1 = PropertyState(**property_details)
state_1.save()
self.state_1 = PropertyState.objects.get(pk=state_1.id)
self.cycle_factory = FakeCycleFactory(organization=self.org,
user=self.user)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_1 = self.property_factory.get_property()
self.property_view_1 = PropertyView.objects.create(
property=self.property_1, cycle=self.cycle, state=self.state_1)
self.import_record = ImportRecord.objects.create(
owner=self.user,
last_modified_by=self.user,
super_organization=self.org)
filename = "example-GreenButton-data.xml"
filepath = os.path.dirname(
os.path.abspath(__file__)) + "/data/" + filename
self.import_file = ImportFile.objects.create(
import_record=self.import_record,
source_type="GreenButton",
uploaded_filename=filename,
file=SimpleUploadedFile(name=filename,
content=open(filepath, 'rb').read()),
cycle=self.cycle,
matching_results_data={"property_id": self.property_1.id})
self.tz_obj = timezone(TIME_ZONE)
def test_property_existing_in_multiple_cycles_can_have_meters_and_readings_associated_to_it(
self):
property_details = FakePropertyStateFactory(
organization=self.org).get_details()
property_details['organization_id'] = self.org.id
# new state to be associated to new cycle using the same pm_property_id as state in old cycle
property_details['pm_property_id'] = self.state_1.pm_property_id
state = PropertyState(**property_details)
state.save()
new_property_state = PropertyState.objects.get(pk=state.id)
new_cycle_factory = FakeCycleFactory(organization=self.org,
user=self.user)
new_cycle = new_cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
# new state and cycle associated to old property
PropertyView.objects.create(property=self.property_1,
cycle=new_cycle,
state=new_property_state)
url = reverse("api:v3:import_files-start-save-data",
args=[self.import_file.id])
url += f'?organization_id={self.org.pk}'
post_params = {
'cycle_id': self.cycle.pk,
}
self.client.post(url, post_params)
refreshed_property_1 = Property.objects.get(pk=self.property_1.id)
self.assertEqual(refreshed_property_1.meters.all().count(), 2)
def setUp(self):
self.properties = []
self.maxDiff = None
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(email='*****@*****.**', **user_details)
self.org, _, _ = create_organization(self.user)
# create a default cycle
self.cycle = Cycle.objects.filter(organization_id=self.org).first()
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.label_factory = FakeStatusLabelFactory(
organization=self.org
)
self.property_view = self.property_view_factory.get_property_view()
self.urls = ['http://example.com', 'http://example.org']
self.client.login(**user_details)
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_taxlots_merge_without_losing_pairings(self):
# Create 2 pairings and distribute them to the two -Views.
property_factory = FakePropertyFactory(organization=self.org)
property_state_factory = FakePropertyStateFactory(
organization=self.org)
property_1 = property_factory.get_property()
state_1 = property_state_factory.get_property_state()
property_view_1 = PropertyView.objects.create(property=property_1,
cycle=self.cycle,
state=state_1)
property_2 = property_factory.get_property()
state_2 = property_state_factory.get_property_state()
property_view_2 = PropertyView.objects.create(property=property_2,
cycle=self.cycle,
state=state_2)
TaxLotProperty(primary=True,
cycle_id=self.cycle.id,
property_view_id=property_view_1.id,
taxlot_view_id=self.view_1.id).save()
TaxLotProperty(primary=True,
cycle_id=self.cycle.id,
property_view_id=property_view_2.id,
taxlot_view_id=self.view_2.id).save()
# Merge the taxlots
url = reverse('api:v2:taxlots-merge') + '?organization_id={}'.format(
self.org.pk)
post_params = json.dumps({
'state_ids': [self.state_2.pk,
self.state_1.pk] # priority given to state_1
})
self.client.post(url, post_params, content_type='application/json')
# There should still be 2 TaxLotProperties
self.assertEqual(TaxLotProperty.objects.count(), 2)
taxlot_view = TaxLotView.objects.first()
paired_propertyview_ids = list(
TaxLotProperty.objects.filter(
taxlot_view_id=taxlot_view.id).values_list('property_view_id',
flat=True))
self.assertCountEqual(paired_propertyview_ids,
[property_view_1.id, property_view_2.id])
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.column_factory = FakeColumnFactory(organization=self.org)
self.cycle_factory = FakeCycleFactory(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)
self.taxlot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone()))
self.client.login(**user_details)
def test_error_occurs_when_trying_to_apply_a_label_to_propertyview_from_a_different_org(
self):
org_1_property = Property.objects.create(organization=self.org)
property_state_factory = FakePropertyStateFactory(
organization=self.org)
org_1_propertystate = property_state_factory.get_property_state()
org_1_propertyview = PropertyView.objects.create(
property=org_1_property,
state=org_1_propertystate,
cycle=self.cycle)
# Via Label API View
with transaction.atomic():
with self.assertRaises(IntegrityError):
self.api_view.add_labels(
self.api_view.models['property'].objects.none(),
'property', [org_1_propertyview.id],
[self.org_2_status_label.id])
# Via PropertyView Model
with transaction.atomic():
with self.assertRaises(IntegrityError):
org_1_propertyview.labels.add(self.org_2_status_label)
# Via PropertyState Rule with Label
org_1_dq = DataQualityCheck.objects.get(organization=self.org)
org_1_ps_rule = org_1_dq.rules.filter(
table_name='PropertyState').first()
# Purposely give an Org 1 Rule an Org 2 Label
org_1_ps_rule.status_label = self.org_2_status_label
org_1_ps_rule.save()
with transaction.atomic():
with self.assertRaises(IntegrityError):
org_1_dq.update_status_label(
self.PropertyViewLabels,
Rule.objects.get(pk=org_1_ps_rule.id),
org_1_propertyview.id,
)
self.assertFalse(
PropertyView.objects.get(
pk=org_1_propertyview.id).labels.all().exists())
def setUp(self):
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **user_details
)
self.org, _, _ = create_organization(self.user)
self.client.login(**user_details)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.tax_lot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.extra_data_column = Column.objects.create(
table_name='PropertyState',
column_name='test_column',
organization=self.org,
is_extra_data=True,
)
def setUp(self):
selfvars = self.set_up(ASSESSED_RAW)
self.user, self.org, self.import_file_1, self.import_record_1, self.cycle_1 = selfvars
cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.cycle_2 = cycle_factory.get_cycle(name="Cycle 2")
self.import_record_2, self.import_file_2 = self.create_import_file(
self.user, self.org, self.cycle_2
)
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.client.login(**user_details)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(organization=self.org)
def setUp(self):
self.maxDiff = None
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.column_list_factory = FakeColumnListSettingsFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone())
)
class ProfileIdMixInclass(ProfileIdMixin):
pass
self.mixin_class = ProfileIdMixInclass()
def test_geocode_buildings_is_unsuccessful_when_the_API_key_is_invalid_or_expired(self):
with base_vcr.use_cassette('seed/tests/data/vcr_cassettes/geocode_invalid_or_expired_key.yaml'):
self.org_fake_key, _, _ = create_organization(self.user)
self.org_fake_key.mapquest_api_key = 'fakeapikey'
self.org_fake_key.save()
self.property_state_factory_fake_key = FakePropertyStateFactory(organization=self.org_fake_key)
property_details_fake_key = self.property_state_factory_fake_key.get_details()
property_details_fake_key['organization_id'] = self.org_fake_key.id
property_details_fake_key['address_line_1'] = "3001 Brighton Blvd"
property_details_fake_key['address_line_2'] = "suite 2693"
property_details_fake_key['city'] = "Denver"
property_details_fake_key['state'] = "Colorado"
property_details_fake_key['postal_code'] = "80216"
property = PropertyState(**property_details_fake_key)
property.save()
properties = PropertyState.objects.filter(pk=property.id)
with self.assertRaises(MapQuestAPIKeyError):
geocode_buildings(properties)
def test_geocode_buildings_doesnt_run_an_api_request_when_an_API_key_is_not_provided(self):
self.org_no_key, _, _ = create_organization(self.user)
self.property_state_factory_no_key = FakePropertyStateFactory(organization=self.org_no_key)
property_details_no_key = self.property_state_factory_no_key.get_details()
property_details_no_key['organization_id'] = self.org_no_key.id
property_details_no_key['address_line_1'] = "3001 Brighton Blvd"
property_details_no_key['address_line_2'] = "suite 2693"
property_details_no_key['city'] = "Denver"
property_details_no_key['state'] = "Colorado"
property_details_no_key['postal_code'] = "80216"
property = PropertyState(**property_details_no_key)
property.save()
properties = PropertyState.objects.filter(pk=property.id)
self.assertIsNone(geocode_buildings(properties))
refreshed_property = PropertyState.objects.get(pk=property.id)
self.assertIsNone(refreshed_property.long_lat)
self.assertIsNone(refreshed_property.geocoding_confidence)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone())
)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.property_view_factory = FakePropertyViewFactory(organization=self.org, cycle=self.cycle)
self.taxlot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.taxlot_view_factory = FakeTaxLotViewFactory(organization=self.org, cycle=self.cycle)
# create 10 addresses that are exactly the same
import_record = ImportRecord.objects.create(super_organization=self.org)
self.import_file = ImportFile.objects.create(
import_record=import_record,
cycle=self.cycle,
)
class TestMatchingHelperMethods(DataMappingBaseTestCase):
def setUp(self):
selfvars = self.set_up(ASSESSED_RAW)
self.user, self.org, self.import_file, self.import_record, self.cycle = selfvars
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(
organization=self.org)
def test_save_state_match(self):
# create a couple states to merge together
ps_1 = self.property_state_factory.get_property_state(
property_name="this should persist")
ps_2 = self.property_state_factory.get_property_state(
extra_data={"extra_1": "this should exist too"})
priorities = Column.retrieve_priorities(self.org.pk)
merged_state = save_state_match(ps_1, ps_2, priorities)
self.assertEqual(merged_state.merge_state, MERGE_STATE_MERGED)
self.assertEqual(merged_state.property_name, ps_1.property_name)
self.assertEqual(merged_state.extra_data['extra_1'],
"this should exist too")
# verify that the audit log is correct.
pal = PropertyAuditLog.objects.get(organization=self.org,
state=merged_state)
self.assertEqual(pal.name, 'System Match')
self.assertEqual(pal.parent_state1, ps_1)
self.assertEqual(pal.parent_state2, ps_2)
self.assertEqual(pal.description, 'Automatic Merge')
def test_filter_duplicate_states(self):
for i in range(10):
self.property_state_factory.get_property_state(
no_default_data=True,
address_line_1='123 The Same Address',
# extra_data={"extra_1": "value_%s" % i},
import_file_id=self.import_file.id,
data_state=DATA_STATE_MAPPING,
)
for i in range(5):
self.property_state_factory.get_property_state(
import_file_id=self.import_file.id,
data_state=DATA_STATE_MAPPING,
)
props = self.import_file.find_unmatched_property_states()
uniq_state_ids, dup_state_count = filter_duplicate_states(props)
# There should be 6 uniq states. 5 from the second call, and one of 'The Same Address'
self.assertEqual(len(uniq_state_ids), 6)
self.assertEqual(dup_state_count, 9)
def test_pm_property_id_existing_across_two_different_orgs_wont_lead_to_misassociated_meters(
self):
new_org, _, _ = create_organization(self.user)
property_details = FakePropertyStateFactory(
organization=new_org).get_details()
property_details['organization_id'] = new_org.id
# new state to be associated to property of different organization but has the same pm_property_id
property_details['pm_property_id'] = self.state_1.pm_property_id
state = PropertyState(**property_details)
state.save()
new_property_state = PropertyState.objects.get(pk=state.id)
new_cycle_factory = FakeCycleFactory(organization=new_org,
user=self.user)
new_cycle = new_cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
new_property = self.property_factory.get_property()
PropertyView.objects.create(property=new_property,
cycle=new_cycle,
state=new_property_state)
url = reverse("api:v3:import_files-start-save-data",
args=[self.import_file.id])
url += f'?organization_id={self.org.pk}'
post_params = {
'cycle_id': self.cycle.pk,
}
self.client.post(url, post_params)
# self.property_1 is associated to self.org, so according to post request, it should have 2 meters
refreshed_property_1 = Property.objects.get(
pk=self.property_1.id, organization_id__exact=self.org.pk)
self.assertEqual(refreshed_property_1.meters.all().count(), 2)
refreshed_new_property = Property.objects.get(pk=new_property.id)
self.assertEqual(refreshed_new_property.meters.count(), 0)
