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.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
self.column_list_factory = FakeColumnListSettingsFactory(organization=self.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, 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()
class TestProfileIdMixin(TestCase):
"""Test OrgMixin -- provides get_organization_id method"""
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 tearDown(self):
PropertyView.objects.all().delete()
self.user.delete()
self.org.delete()
self.org_user.delete()
def test_get_profile_id(self):
"""test get_organization method"""
state = self.property_state_factory.get_property_state(extra_data={"field_1": "value_1"})
prprty = self.property_factory.get_property()
PropertyView.objects.create(
property=prprty, cycle=self.cycle, state=state
)
# save all the columns in the state to the database so we can setup column list settings
Column.save_column_names(state)
columns = self.mixin_class.get_show_columns(self.org.id, None)
self.assertGreater(len(columns['fields']), 10)
self.assertListEqual(columns['extra_data'], ['field_1'])
columns = self.mixin_class.get_show_columns(self.org.id, -1)
self.assertGreater(len(columns['fields']), 10)
self.assertListEqual(columns['extra_data'], ['field_1'])
columns = self.mixin_class.get_show_columns(self.org.id, 1000000)
self.assertGreater(len(columns['fields']), 10)
self.assertListEqual(columns['extra_data'], ['field_1'])
# no extra data
columnlistsetting = self.column_list_factory.get_columnlistsettings(
columns=['address_line_1', 'site_eui']
)
columns = self.mixin_class.get_show_columns(self.org.id, columnlistsetting.id)
self.assertListEqual(columns['fields'], ['extra_data', 'id', 'address_line_1', 'site_eui'])
self.assertListEqual(columns['extra_data'], [])
# with extra data
columnlistsetting = self.column_list_factory.get_columnlistsettings(
columns=['address_line_1', 'site_eui', 'field_1']
)
columns = self.mixin_class.get_show_columns(self.org.id, columnlistsetting.id)
self.assertListEqual(columns['fields'], ['extra_data', 'id', 'address_line_1', 'site_eui'])
self.assertListEqual(columns['extra_data'], ['field_1'])
class TaxLotViewTests(DataMappingBaseTestCase):
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.client.login(**user_details)
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.taxlot_factory = FakeTaxLotFactory(organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(
organization=self.org)
self.column_list_factory = FakeColumnListSettingsFactory(
organization=self.org)
def test_get_links_for_a_single_property(self):
# Create 2 linked property sets
state = self.taxlot_state_factory.get_taxlot_state(
extra_data={"field_1": "value_1"})
taxlot = self.taxlot_factory.get_taxlot()
view_1 = TaxLotView.objects.create(taxlot=taxlot,
cycle=self.cycle,
state=state)
later_cycle = self.cycle_factory.get_cycle(
start=datetime(2100, 10, 10, tzinfo=get_current_timezone()))
state_2 = self.taxlot_state_factory.get_taxlot_state(
extra_data={"field_1": "value_2"})
view_2 = TaxLotView.objects.create(taxlot=taxlot,
cycle=later_cycle,
state=state_2)
# save all the columns in the state to the database
Column.save_column_names(state)
url = reverse('api:v2:taxlots-links', args=[view_1.id])
post_params = json.dumps({'organization_id': self.org.pk})
response = self.client.post(url,
post_params,
content_type='application/json')
data = response.json()['data']
self.assertEqual(len(data), 2)
# results should be ordered by descending cycle start date
result_1 = data[1]
self.assertEqual(result_1['address_line_1'], state.address_line_1)
self.assertEqual(result_1['extra_data']['field_1'], 'value_1')
self.assertEqual(result_1['cycle_id'], self.cycle.id)
self.assertEqual(result_1['view_id'], view_1.id)
result_2 = data[0]
self.assertEqual(result_2['address_line_1'], state_2.address_line_1)
self.assertEqual(result_2['extra_data']['field_1'], 'value_2')
self.assertEqual(result_2['cycle_id'], later_cycle.id)
self.assertEqual(result_2['view_id'], view_2.id)
def test_first_lat_long_edit(self):
state = self.taxlot_state_factory.get_taxlot_state()
taxlot = self.taxlot_factory.get_taxlot()
view = TaxLotView.objects.create(taxlot=taxlot,
cycle=self.cycle,
state=state)
# update the address
new_data = {
"state": {
"latitude": 39.765251,
"longitude": -104.986138,
}
}
url = reverse('api:v2:taxlots-detail', args=[
view.id
]) + '?organization_id={}'.format(self.org.pk)
response = self.client.put(url,
json.dumps(new_data),
content_type='application/json')
data = json.loads(response.content)
self.assertEqual(data['status'], 'success')
response = self.client.get(url, content_type='application/json')
data = json.loads(response.content)
self.assertEqual(data['status'], 'success')
self.assertIsNotNone(data['state']['long_lat'])
self.assertIsNotNone(data['state']['geocoding_confidence'])
def test_merged_indicators_provided_on_filter_endpoint(self):
_import_record, import_file_1 = self.create_import_file(
self.user, self.org, self.cycle)
base_details = {
'address_line_1': '123 Match Street',
'import_file_id': import_file_1.id,
'data_state': DATA_STATE_MAPPING,
'no_default_data': False,
}
self.taxlot_state_factory.get_taxlot_state(**base_details)
# set import_file_1 mapping done so that record is "created for users to view".
import_file_1.mapping_done = True
import_file_1.save()
match_buildings(import_file_1.id)
_import_record_2, import_file_2 = self.create_import_file(
self.user, self.org, self.cycle)
url = reverse(
'api:v2:taxlots-filter'
) + '?cycle_id={}&organization_id={}&page=1&per_page=999999999'.format(
self.cycle.pk, self.org.pk)
response = self.client.post(url)
data = json.loads(response.content)
self.assertFalse(data['results'][0]['merged_indicator'])
# make sure merged_indicator is True when merge occurs
base_details['city'] = 'Denver'
base_details['import_file_id'] = import_file_2.id
self.taxlot_state_factory.get_taxlot_state(**base_details)
# set import_file_2 mapping done so that match merging can occur.
import_file_2.mapping_done = True
import_file_2.save()
match_buildings(import_file_2.id)
url = reverse(
'api:v2:taxlots-filter'
) + '?cycle_id={}&organization_id={}&page=1&per_page=999999999'.format(
self.cycle.pk, self.org.pk)
response = self.client.post(url)
data = json.loads(response.content)
self.assertTrue(data['results'][0]['merged_indicator'])
# Create pairings and check if paired object has indicator as well
property_factory = FakePropertyFactory(organization=self.org)
property_state_factory = FakePropertyStateFactory(
organization=self.org)
property = property_factory.get_property()
property_state = property_state_factory.get_property_state()
property_view = PropertyView.objects.create(property=property,
cycle=self.cycle,
state=property_state)
# attach pairing to one and only taxlot_view
TaxLotProperty(primary=True,
cycle_id=self.cycle.id,
property_view_id=property_view.id,
taxlot_view_id=TaxLotView.objects.get().id).save()
url = reverse(
'api:v2:taxlots-filter'
) + '?cycle_id={}&organization_id={}&page=1&per_page=999999999'.format(
self.cycle.pk, self.org.pk)
response = self.client.post(url)
data = json.loads(response.content)
related = data['results'][0]['related'][0]
self.assertTrue('merged_indicator' in related)
self.assertFalse(related['merged_indicator'])
def test_taxlot_match_merge_link(self):
base_details = {
'jurisdiction_tax_lot_id': '123MatchID',
'no_default_data': False,
}
tls_1 = self.taxlot_state_factory.get_taxlot_state(**base_details)
taxlot = self.taxlot_factory.get_taxlot()
view_1 = TaxLotView.objects.create(taxlot=taxlot,
cycle=self.cycle,
state=tls_1)
cycle_2 = self.cycle_factory.get_cycle(
start=datetime(2018, 10, 10, tzinfo=get_current_timezone()))
tls_2 = self.taxlot_state_factory.get_taxlot_state(**base_details)
taxlot_2 = self.taxlot_factory.get_taxlot()
TaxLotView.objects.create(taxlot=taxlot_2, cycle=cycle_2, state=tls_2)
url = reverse('api:v2:taxlots-match-merge-link', args=[view_1.id])
response = self.client.post(url, content_type='application/json')
summary = response.json()
expected_summary = {
'view_id': None,
'match_merged_count': 0,
'match_link_count': 1,
}
self.assertEqual(expected_summary, summary)
refreshed_view_1 = TaxLotView.objects.get(state_id=tls_1.id)
view_2 = TaxLotView.objects.get(state_id=tls_2.id)
self.assertEqual(refreshed_view_1.taxlot_id, view_2.taxlot_id)
def test_taxlots_cycles_list(self):
# Create TaxLot set in cycle 1
state = self.taxlot_state_factory.get_taxlot_state(
extra_data={"field_1": "value_1"})
taxlot = self.taxlot_factory.get_taxlot()
TaxLotView.objects.create(taxlot=taxlot, cycle=self.cycle, state=state)
cycle_2 = self.cycle_factory.get_cycle(
start=datetime(2018, 10, 10, tzinfo=get_current_timezone()))
state_2 = self.taxlot_state_factory.get_taxlot_state(
extra_data={"field_1": "value_2"})
taxlot_2 = self.taxlot_factory.get_taxlot()
TaxLotView.objects.create(taxlot=taxlot_2,
cycle=cycle_2,
state=state_2)
# save all the columns in the state to the database so we can setup column list settings
Column.save_column_names(state)
# get the columnlistsetting (default) for all columns
columnlistsetting = self.column_list_factory.get_columnlistsettings(
inventory_type=VIEW_LIST_TAXLOT,
columns=['address_line_1', 'field_1'],
table_name='TaxLotState')
post_params = json.dumps({
'organization_id': self.org.pk,
'profile_id': columnlistsetting.id,
'cycle_ids': [self.cycle.id, cycle_2.id]
})
url = reverse('api:v2:taxlots-cycles')
response = self.client.post(url,
post_params,
content_type='application/json')
data = response.json()
address_line_1_key = 'address_line_1_' + str(
columnlistsetting.columns.get(column_name='address_line_1').id)
field_1_key = 'field_1_' + str(
columnlistsetting.columns.get(column_name='field_1').id)
self.assertEqual(len(data), 2)
result_1 = data[str(self.cycle.id)]
self.assertEqual(result_1[0][address_line_1_key], state.address_line_1)
self.assertEqual(result_1[0][field_1_key], 'value_1')
self.assertEqual(result_1[0]['id'], taxlot.id)
result_2 = data[str(cycle_2.id)]
self.assertEqual(result_2[0][address_line_1_key],
state_2.address_line_1)
self.assertEqual(result_2[0][field_1_key], 'value_2')
self.assertEqual(result_2[0]['id'], taxlot_2.id)
class PropertyViewTests(DeleteModelsTestCase):
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=get_current_timezone()))
self.column_list_factory = FakeColumnListSettingsFactory(
organization=self.org)
self.client.login(**user_details)
def test_get_and_edit_properties(self):
state = self.property_state_factory.get_property_state()
prprty = self.property_factory.get_property()
view = PropertyView.objects.create(property=prprty,
cycle=self.cycle,
state=state)
params = {
'organization_id': self.org.pk,
'page': 1,
'per_page': 999999999,
'columns': COLUMNS_TO_SEND,
}
url = reverse('api:v2.1:properties-list') + '?cycle_id={}'.format(
self.cycle.pk)
response = self.client.get(url, params)
data = json.loads(response.content)
self.assertEqual(len(data['properties']), 1)
result = data['properties'][0]
self.assertEqual(result['state']['address_line_1'],
state.address_line_1)
db_created_time = result['created']
db_updated_time = result['updated']
self.assertTrue(db_created_time is not None)
self.assertTrue(db_updated_time is not None)
# update the address
new_data = {"state": {"address_line_1": "742 Evergreen Terrace"}}
url = reverse('api:v2:properties-detail', args=[
view.id
]) + '?organization_id={}'.format(self.org.pk)
response = self.client.put(url,
json.dumps(new_data),
content_type='application/json')
data = json.loads(response.content)
self.assertEqual(data['status'], 'success')
# the above call returns data from the PropertyState, need to get the Property --
# call the get on the same API to retrieve it
response = self.client.get(url, content_type='application/json')
data = json.loads(response.content)
# make sure the address was updated and that the datetimes were modified
self.assertEqual(data['status'], 'success')
self.assertEqual(data['state']['address_line_1'],
'742 Evergreen Terrace')
self.assertEqual(
datetime.strptime(db_created_time,
"%Y-%m-%dT%H:%M:%S.%fZ").replace(microsecond=0),
datetime.strptime(data['property']['created'],
"%Y-%m-%dT%H:%M:%S.%fZ").replace(microsecond=0))
self.assertGreater(
datetime.strptime(data['property']['updated'],
"%Y-%m-%dT%H:%M:%S.%fZ"),
datetime.strptime(db_updated_time, "%Y-%m-%dT%H:%M:%S.%fZ"))
def test_list_properties_with_profile_id(self):
state = self.property_state_factory.get_property_state(
extra_data={"field_1": "value_1"})
prprty = self.property_factory.get_property()
PropertyView.objects.create(property=prprty,
cycle=self.cycle,
state=state)
# save all the columns in the state to the database so we can setup column list settings
Column.save_column_names(state)
# get the columnlistsetting (default) for all columns
columnlistsetting = self.column_list_factory.get_columnlistsettings(
columns=['address_line_1', 'field_1'])
params = {
'organization_id': self.org.pk,
'profile_id': columnlistsetting.id,
}
url = reverse('api:v2.1:properties-list') + '?cycle_id={}'.format(
self.cycle.pk)
response = self.client.get(url, params)
data = response.json()
self.assertEqual(len(data['properties']), 1)
result = data['properties'][0]
self.assertEqual(result['state']['address_line_1'],
state.address_line_1)
self.assertEqual(result['state']['extra_data']['field_1'], 'value_1')
self.assertFalse(result['state'].get('city', None))
def test_search_identifier(self):
self.property_view_factory.get_property_view(cycle=self.cycle,
custom_id_1='123456')
self.property_view_factory.get_property_view(
cycle=self.cycle, custom_id_1='987654 Long Street')
self.property_view_factory.get_property_view(
cycle=self.cycle, address_line_1='123 Main Street')
self.property_view_factory.get_property_view(
cycle=self.cycle,
address_line_1='Hamilton Road',
analysis_state=PropertyState.ANALYSIS_STATE_QUEUED)
self.property_view_factory.get_property_view(
cycle=self.cycle,
custom_id_1='long road',
analysis_state=PropertyState.ANALYSIS_STATE_QUEUED)
# Typically looks like this
# http://localhost:8000/api/v2.1/properties/?organization_id=265&cycle=219&identifier=09-IS
# check for all items
query_params = "?cycle={}&organization_id={}".format(
self.cycle.pk, self.org.pk)
url = reverse('api:v2.1:properties-list') + query_params
response = self.client.get(url)
result = json.loads(response.content)
self.assertEqual(result['status'], 'success')
results = result['properties']
self.assertEqual(len(results), 5)
# check for 2 items with 123
query_params = "?cycle={}&organization_id={}&identifier={}".format(
self.cycle.pk, self.org.pk, '123')
url = reverse('api:v2.1:properties-list') + query_params
response = self.client.get(url)
result = json.loads(response.content)
self.assertEqual(result['status'], 'success')
results = result['properties']
# print out the result of this when there are more than two in an attempt to catch the
# non-deterministic part of this test
if len(results) > 2:
print(results)
self.assertEqual(len(results), 2)
# check the analysis states
query_params = "?cycle={}&organization_id={}&analysis_state={}".format(
self.cycle.pk, self.org.pk, 'Completed')
url = reverse('api:v2.1:properties-list') + query_params
response = self.client.get(url)
result = json.loads(response.content)
self.assertEqual(result['status'], 'success')
results = result['properties']
self.assertEqual(len(results), 0)
query_params = "?cycle={}&organization_id={}&analysis_state={}".format(
self.cycle.pk, self.org.pk, 'Not Started')
url = reverse('api:v2.1:properties-list') + query_params
response = self.client.get(url)
result = json.loads(response.content)
self.assertEqual(result['status'], 'success')
results = result['properties']
self.assertEqual(len(results), 3)
query_params = "?cycle={}&organization_id={}&analysis_state={}".format(
self.cycle.pk, self.org.pk, 'Queued')
url = reverse('api:v2.1:properties-list') + query_params
response = self.client.get(url)
result = json.loads(response.content)
self.assertEqual(result['status'], 'success')
results = result['properties']
self.assertEqual(len(results), 2)
# check the combination of both the identifier and the analysis state
query_params = "?cycle={}&organization_id={}&identifier={}&analysis_state={}".format(
self.cycle.pk, self.org.pk, 'Long', 'Queued')
url = reverse('api:v2.1:properties-list') + query_params
response = self.client.get(url)
result = json.loads(response.content)
self.assertEqual(result['status'], 'success')
results = result['properties']
self.assertEqual(len(results), 1)
def test_meters_exist(self):
# Create a property set with meters
state_1 = self.property_state_factory.get_property_state()
property_1 = self.property_factory.get_property()
PropertyView.objects.create(property=property_1,
cycle=self.cycle,
state=state_1)
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
import_file = ImportFile.objects.create(
import_record=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": property_1.id
} # this is how target property is specified
)
gb_import_url = reverse("api:v2:import_files-save-raw-data",
args=[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)
# Create a property set without meters
state_2 = self.property_state_factory.get_property_state()
property_2 = self.property_factory.get_property()
PropertyView.objects.create(property=property_2,
cycle=self.cycle,
state=state_2)
url = reverse('api:v2:properties-meters-exist')
true_post_params = json.dumps(
{'inventory_ids': [property_2.pk, property_1.pk]})
true_result = self.client.post(url,
true_post_params,
content_type='application/json')
self.assertEqual(b'true', true_result.content)
false_post_params = json.dumps({'inventory_ids': [property_2.pk]})
false_result = self.client.post(url,
false_post_params,
content_type='application/json')
self.assertEqual(b'false', false_result.content)