def test_like_filter(self):
species = Species(
instance=self.instance,
common_name='this is a test species',
genus='Genus-1',
otm_code='S1')
species.save_with_user(self.commander)
p, t = self.create_tree_and_plot()
t.species = species
t.save_with_user(self.commander)
species_like_filter = json.dumps({
'species.common_name':
{'LIKE': 's a tes'}})
plots = search.Filter(species_like_filter, '', self.instance)\
.get_objects(Plot)
result = [o.pk for o in plots]
self.assertEqual(result, [p.pk])
species.common_name = 'no match'
species.save_with_user(self.commander)
plots = search.Filter(species_like_filter, '', self.instance)\
.get_objects(Plot)
self.assertEqual(len(plots), 0)
def test_like_filter(self):
species = Species(instance=self.instance,
common_name='this is a test species',
genus='Genus-1',
otm_code='S1')
species.save_with_user(self.commander)
p, t = self.create_tree_and_plot()
t.species = species
t.save_with_user(self.commander)
species_like_filter = json.dumps(
{'species.common_name': {
'LIKE': 's a tes'
}})
plots = search.Filter(species_like_filter, '', self.instance)\
.get_objects(Plot)
result = [o.pk for o in plots]
self.assertEqual(result, [p.pk])
species.common_name = 'no match'
species.save_with_user(self.commander)
plots = search.Filter(species_like_filter, '', self.instance)\
.get_objects(Plot)
self.assertEqual(len(plots), 0)
def test_like_filter(self):
species = Species(
instance=self.instance,
common_name='this is a test species',
genus='Genus-1',
otm_code='S1')
species.save_with_user(self.commander)
p, t = self.create_tree_and_plot()
t.species = species
t.save_with_user(self.commander)
species_like_filter = json.dumps({
'species.common_name':
{'LIKE': 's a tes'}})
result = [o.pk for o in
_execute_filter(
self.instance, species_like_filter)]
self.assertEqual(result, [p.pk])
species.common_name = 'no match'
species.save_with_user(self.commander)
result = _execute_filter(
self.instance, species_like_filter)
self.assertEqual(len(result), 0)
def test_update_species(self):
with self._assert_updates_eco_rev(True):
tree = Tree(instance=self.instance, plot=self.plot)
tree.save_with_user(self.user)
species = Species(common_name='foo', instance=self.instance)
species.save_with_user(self.user)
request_dict = {'tree.species': species.pk}
update_map_feature(request_dict, self.user, self.plot)
def setUp(self):
instance = make_instance()
user = make_admin_user(instance)
species = Species(instance=instance, genus="g1", species="", cultivar="", max_diameter=50.0, max_height=100.0)
species.save_with_user(User.system_user())
login(self.client, user.username)
def test_update_species(self):
with self._assert_updates_eco_rev(True):
tree = Tree(instance=self.instance, plot=self.plot)
tree.save_with_user(self.user)
species = Species(common_name='foo', instance=self.instance)
species.save_with_user(self.user)
request_dict = {'tree.species': species.pk}
update_map_feature(request_dict, self.user, self.plot)
def setUp(self):
self.instance = make_instance()
user = make_commander_user(instance=self.instance)
species = Species(instance=self.instance,
otm_code='',
common_name='',
genus='')
species.save_with_user(user)
def setUp(self):
instance = make_instance()
user = make_admin_user(instance)
species = Species(instance=instance, genus='g1', species='',
cultivar='', max_diameter=50.0, max_height=100.0)
species.save_with_user(User.system_user())
login(self.client, user.username)
def test_height_too_large_for_species_fails_validation(self):
max_height = 1
s = Species(genus='Ulmus', species='rubra', cultivar='Columella',
instance=self.instance, max_height=max_height)
s.save_with_user(self.user)
self.tree.species = s
self.tree.height = str(max_height + 1)
with self.assertRaises(ValidationError) as cm:
self.tree.save_with_user(self.user)
self.assertValidationErrorDictContainsKey(cm.exception, 'height')
def test_adding_override_invalidates_cache(self):
instance = make_instance()
user = make_commander_user(instance)
species = Species(instance=instance, genus='g')
species.save_with_user(user)
species.refresh_from_db()
ITreeCodeOverride(instance_species=species,
region=ITreeRegion.objects.get(code='NMtnPrFNL'),
itree_code='CEL OTHER').save_with_user(user)
invalidate_ecoservice_cache_if_stale()
self.assertTrue(self.cache_invalidated)
def test_species_id_search(self):
species1 = Species(
common_name='Species-1',
genus='Genus-1',
otm_code='S1',
instance=self.instance)
species1.save_with_user(self.commander)
species2 = Species(
common_name='Species-2',
genus='Genus-2',
otm_code='S1',
instance=self.instance)
species2.save_with_user(self.commander)
p1, t1 = self.create_tree_and_plot()
p2, t2 = self.create_tree_and_plot()
p3, t3 = self.create_tree_and_plot()
t1.species = species1
t1.save_with_user(self.commander)
t2.species = species2
t2.save_with_user(self.commander)
species1_filter = json.dumps({'species.id': species1.pk})
species2_filter = json.dumps({'species.id': species2.pk})
species3_filter = json.dumps({'species.id': -1})
plots =\
search.Filter(species1_filter, '', self.instance).get_objects(Plot)
self.assertEqual(
{p1.pk},
{p.pk
for p in plots})
plots =\
search.Filter(species2_filter, '', self.instance).get_objects(Plot)
self.assertEqual(
{p2.pk},
{p.pk
for p in plots})
plots =\
search.Filter(species3_filter, '', self.instance).get_objects(Plot)
self.assertEqual(
0, len(plots))
def test_species_id_search(self):
species1 = Species(
common_name='Species-1',
genus='Genus-1',
otm_code='S1',
instance=self.instance)
species1.save_with_user(self.commander)
species2 = Species(
common_name='Species-2',
genus='Genus-2',
otm_code='S1',
instance=self.instance)
species2.save_with_user(self.commander)
p1, t1 = self.create_tree_and_plot()
p2, t2 = self.create_tree_and_plot()
p3, t3 = self.create_tree_and_plot()
t1.species = species1
t1.save_with_user(self.commander)
t2.species = species2
t2.save_with_user(self.commander)
species1_filter = json.dumps({'species.id': species1.pk})
species2_filter = json.dumps({'species.id': species2.pk})
species3_filter = json.dumps({'species.id': -1})
plots =\
search.Filter(species1_filter, '', self.instance).get_objects(Plot)
self.assertEqual(
{p1.pk},
{p.pk
for p in plots})
plots =\
search.Filter(species2_filter, '', self.instance).get_objects(Plot)
self.assertEqual(
{p2.pk},
{p.pk
for p in plots})
plots =\
search.Filter(species3_filter, '', self.instance).get_objects(Plot)
self.assertEqual(
0, len(plots))
def setupTreemapEnv():
def local_render_to_response(*args, **kwargs):
from django.template import loader
from django.http import HttpResponse
httpresponse_kwargs = {'mimetype': kwargs.pop('mimetype', None)}
hr = HttpResponse(
loader.render_to_string(*args, **kwargs), **httpresponse_kwargs)
if hasattr(args[1], 'dicts'):
hr.request_context = args[1].dicts
return hr
django.shortcuts.render_to_response = local_render_to_response
instance = make_instance(is_public=True)
create_stewardship_udfs(instance)
make_user_with_default_role(instance, 'jim')
commander = make_commander_user(instance, 'commander')
make_apprentice_user(instance, 'apprentice')
n1geom = MultiPolygon(Polygon(
((0, 0), (100, 0), (100, 100), (0, 100), (0, 0))))
n2geom = MultiPolygon(
Polygon(((0, 101), (101, 101), (101, 200), (0, 200), (0, 101))))
n1 = Boundary(name="n1", category='blah', sort_order=4, geom=n1geom)
n2 = Boundary(name="n2", category='blah', sort_order=4, geom=n2geom)
n1.save()
n2.save()
s1 = Species(otm_code="s1", genus="testus1", species="specieius1",
cultivar='', instance=instance)
s2 = Species(otm_code="s2", genus="testus2", species="specieius2",
cultivar='', instance=instance)
s3 = Species(otm_code="s3", genus="testus2", species="specieius3",
cultivar='', instance=instance)
s1.is_native = True
s1.fall_conspicuous = True
s1.flower_conspicuous = True
s1.palatable_human = True
s2.is_native = True
s2.fall_conspicuous = False
s2.flower_conspicuous = True
s2.palatable_human = False
s2.has_wildlife_value = True
s3.has_wildlife_value = True
s1.save_with_user(commander)
s2.save_with_user(commander)
s3.save_with_user(commander)
return instance
def test_tree_hash_to_model(self):
test_plot = Plot(geom=Point(0, 0), instance=self.instance)
test_plot.id = 95
test_plot.save_with_user(self.commander)
test_species = Species(instance=self.instance, otm_code="1",
common_name="asdfa", genus="sdfs")
test_species.id = 85
test_species.save_with_user(self.commander)
tree_dict = json.loads(self.tree_blob)
tree = hash_to_model(MIGRATION_RULES,
'tree', tree_dict, self.instance)
tree.save_with_user(self.commander)
tree = Tree.objects.get(pk=tree.pk)
self.assertEqual(tree.plot, test_plot)
self.assertEqual(tree.species, test_species)
self.assertEqual(tree.readonly, True)
self.assertEqual(tree.diameter, 0.2900001566)
self.assertEqual(tree.canopy_height, None)
self.assertEqual(tree.date_planted, None)
self.assertEqual(tree.date_removed, None)
def setupTreemapEnv():
def local_render_to_response(*args, **kwargs):
from django.template import loader
from django.http import HttpResponse
hr = HttpResponse(loader.render_to_string(*args, **kwargs))
if hasattr(args[1], 'dicts'):
hr.request_context = args[1].dicts
return hr
django.shortcuts.render_to_response = local_render_to_response
instance = make_instance(is_public=True)
create_stewardship_udfs(instance)
make_user_with_default_role(instance, 'jim')
commander = make_commander_user(instance, 'commander')
make_apprentice_user(instance, 'apprentice')
n1geom = MultiPolygon(Polygon(
((0, 0), (100, 0), (100, 100), (0, 100), (0, 0))))
n2geom = MultiPolygon(
Polygon(((0, 101), (101, 101), (101, 200), (0, 200), (0, 101))))
n1 = Boundary(name="n1", category='blah', sort_order=4, geom=n1geom)
n2 = Boundary(name="n2", category='blah', sort_order=4, geom=n2geom)
n1.save()
n2.save()
s1 = Species(otm_code="s1", genus="testus1", species="specieius1",
cultivar='', instance=instance)
s2 = Species(otm_code="s2", genus="testus2", species="specieius2",
cultivar='', instance=instance)
s3 = Species(otm_code="s3", genus="testus2", species="specieius3",
cultivar='', instance=instance)
s1.is_native = True
s1.fall_conspicuous = True
s1.flower_conspicuous = True
s1.palatable_human = True
s2.is_native = True
s2.fall_conspicuous = False
s2.flower_conspicuous = True
s2.palatable_human = False
s2.has_wildlife_value = True
s3.has_wildlife_value = True
s1.save_with_user(commander)
s2.save_with_user(commander)
s3.save_with_user(commander)
return instance
def test_tree_dict_to_model(self):
test_plot = Plot(geom=self.instance.center, instance=self.instance)
test_plot.id = 95
test_plot.save_with_user(self.commander)
test_species = Species(instance=self.instance,
otm_code="1",
common_name="asdfa",
genus="sdfs")
test_species.id = 85
test_species.save_with_user(self.commander)
tree_dict = json.loads(self.tree_blob)
tree = dict_to_model(MIGRATION_RULES, 'tree', tree_dict, self.instance)
tree.save_with_user(self.commander)
tree = Tree.objects.get(pk=tree.pk)
self.assertEqual(tree.plot, test_plot)
self.assertEqual(tree.species, test_species)
self.assertEqual(tree.readonly, True)
self.assertEqual(tree.diameter, 0.2900001566)
self.assertEqual(tree.canopy_height, None)
self.assertEqual(tree.date_planted, None)
self.assertEqual(tree.date_removed, None)
def setUp(self):
self.instance = make_instance()
user = make_commander_user(instance=self.instance)
species = Species(instance=self.instance, otm_code='',
common_name='', genus='')
species.save_with_user(user)
class EcoTest(UrlTestCase):
def setUp(self):
self.instance = make_instance(is_public=True)
self.user = make_commander_user(self.instance)
self.species = Species(otm_code='CEAT',
genus='cedrus',
species='atlantica',
max_dbh=2000,
max_height=100,
instance=self.instance)
self.species.save_with_user(self.user)
ITreeRegion.objects.all().delete()
p1 = Point(-8515941.0, 4953519.0)
self.region_buffer_in_meters = 1000
ITreeRegion.objects.create(
code='NoEastXXX',
geometry=MultiPolygon([p1.buffer(1000)]))
self.plot = Plot(geom=p1,
instance=self.instance)
self.plot.save_with_user(self.user)
self.tree = Tree(plot=self.plot,
instance=self.instance,
readonly=False,
species=self.species,
diameter=1630)
self.tree.save_with_user(self.user)
def test_tree_benefits_url(self):
self.assert_200(
'/%s/eco/benefit/tree/%s/' % (self.instance.url_name,
self.tree.id))
def test_tree_benefit_url_invalid(self):
self.assert_404(
'/%s/eco/benefit/tree/999/' % self.instance.url_name)
def test_group_eco(self):
pass # TODO: Once filtering has been enabled
def assert_benefit_value(self, bens, benefit, unit, value):
self.assertEqual(bens[benefit]['unit'], unit)
self.assertEqual(int(float(bens[benefit]['value'])), value)
def test_eco_benefit_sanity(self):
rslt = tree_benefits(instance=self.instance,
tree_id=self.tree.pk)
bens = rslt['benefits'][0]
self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)
def test_species_for_none_region_lookup(self):
self.assertIsNone(species_codes_for_regions(None))
def test_species_for_region_lookup(self):
northeast = species_codes_for_regions(['NoEastXXX'])
self.assertEqual(258, len(northeast))
south = species_codes_for_regions(['PiedmtCLT'])
self.assertEqual(244, len(south))
combined = species_codes_for_regions(['NoEastXXX', 'PiedmtCLT'])
self.assertEqual(338, len(combined))
combined_set = set(combined)
self.assertEqual(len(combined), len(combined_set),
"Getting the species for more than one region "
"should result in a unique set of otm_codes")
def test_default_region(self):
# move the point outside the eco region
self.plot.geom.x += self.region_buffer_in_meters * 2
self.plot.save_with_user(self.user)
result = tree_benefits(instance=self.instance,
tree_id=self.tree.pk)
bens_wo_default = result['benefits'][0]
self.assert_benefit_value(bens_wo_default, 'energy', 'kwh', 0)
self.assert_benefit_value(bens_wo_default, 'airquality', 'lbs/year', 0)
self.assert_benefit_value(bens_wo_default, 'stormwater', 'gal', 0)
self.assert_benefit_value(bens_wo_default, 'co2', 'lbs/year', 0)
self.instance.itree_region_default = 'NoEastXXX'
self.instance.save()
result = tree_benefits(instance=self.instance,
tree_id=self.tree.pk)
bens_with_default = result['benefits'][0]
self.assert_benefit_value(bens_with_default,
'energy', 'kwh', 1896)
self.assert_benefit_value(bens_with_default,
'airquality', 'lbs/year', 6)
self.assert_benefit_value(bens_with_default,
'stormwater', 'gal', 3185)
self.assert_benefit_value(bens_with_default,
'co2', 'lbs/year', 563)
class EcoTest(UrlTestCase):
def setUp(self):
# Example url for
# CEAT, 1630 dbh, NoEastXXX
# eco.json?otmcode=CEAT&diameter=1630®ion=NoEastXXX
def mockbenefits(*args, **kwargs):
benefits = {
"Benefits": {
"aq_nox_avoided": 0.6792,
"aq_nox_dep": 0.371,
"aq_ozone_dep": 0.775,
"aq_pm10_avoided": 0.0436,
"aq_pm10_dep": 0.491,
"aq_sox_avoided": 0.372,
"aq_sox_dep": 0.21,
"aq_voc_avoided": 0.0254,
"bvoc": -0.077,
"co2_avoided": 255.5,
"co2_sequestered": 0,
"co2_storage": 6575,
"electricity": 187,
"hydro_interception": 12.06,
"natural_gas": 5834.1
}
}
return (benefits, None)
region = ITreeRegion.objects.get(code='NoEastXXX')
p = region.geometry.point_on_surface
self.instance = make_instance(is_public=True, point=p)
self.user = make_commander_user(self.instance)
self.species = Species(otm_code='CEAT',
genus='cedrus',
species='atlantica',
max_diameter=2000,
max_height=100,
instance=self.instance)
self.species.save_with_user(self.user)
self.plot = Plot(geom=p, instance=self.instance)
self.plot.save_with_user(self.user)
self.tree = Tree(plot=self.plot,
instance=self.instance,
readonly=False,
species=self.species,
diameter=1630)
self.tree.save_with_user(self.user)
self.origBenefitFn = ecobackend.json_benefits_call
ecobackend.json_benefits_call = mockbenefits
def tearDown(self):
ecobackend.json_benefits_call = self.origBenefitFn
def assert_benefit_value(self, bens, benefit, unit, value):
self.assertEqual(bens[benefit]['unit'], unit)
self.assertEqual(int(float(bens[benefit]['value'])), value)
def test_eco_benefit_sanity(self):
rslt, basis, error = TreeBenefitsCalculator()\
.benefits_for_object(self.instance, self.tree.plot)
bens = rslt['plot']
self.assert_benefit_value(bens, BenefitCategory.ENERGY, 'kwh', 1896)
self.assert_benefit_value(bens, BenefitCategory.AIRQUALITY, 'lbs', 6)
self.assert_benefit_value(bens, BenefitCategory.STORMWATER, 'gal',
3185)
self.assert_benefit_value(bens, BenefitCategory.CO2, 'lbs', 563)
self.assert_benefit_value(bens, BenefitCategory.CO2STORAGE, 'lbs',
6575)
def testSearchBenefits(self):
request = make_request(
{'q': json.dumps({'tree.readonly': {
'IS': False
}})}) # all trees
request.instance_supports_ecobenefits = self.instance\
.has_itree_region()
result = search_tree_benefits(request, self.instance)
benefits = result['benefits']
self.assertTrue(len(benefits) > 0)
def test_group_basis_empty(self):
basis = {}
example = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 8
},
'group2': {
'n_objects_used': 10,
'n_objects_discarded': 12
}
}
_combine_benefit_basis(basis, example)
self.assertEqual(basis, example)
def test_group_basis_combine_new_group(self):
# New groups are added
basis = {'group1': {'n_objects_used': 5, 'n_objects_discarded': 8}}
new_group = {
'group2': {
'n_objects_used': 13,
'n_objects_discarded': 4
}
}
target = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 8
},
'group2': {
'n_objects_used': 13,
'n_objects_discarded': 4
}
}
_combine_benefit_basis(basis, new_group)
self.assertEqual(basis, target)
def test_group_basis_combine_existing_groups(self):
basis = {'group1': {'n_objects_used': 5, 'n_objects_discarded': 8}}
update_group = {
'group1': {
'n_objects_used': 13,
'n_objects_discarded': 4
}
}
target = {'group1': {'n_objects_used': 18, 'n_objects_discarded': 12}}
_combine_benefit_basis(basis, update_group)
self.assertEqual(basis, target)
def test_combine_benefit_groups_empty(self):
# with and without currency
base_group = {
'group1': {
'benefit1': {
'value': 3,
'currency': 9,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit2': {
'value': 3,
'currency': 9,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
}
}
}
groups = {}
_combine_grouped_benefits(groups, base_group)
self.assertEqual(groups, base_group)
def test_combine_benefit_groups_no_overlap(self):
base_group = {
'group1': {
'benefit1': {
'value': 3,
'currency': 9,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit2': {
'value': 4,
'currency': 10,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
}
}
}
new_group = {
'group2': {
'benefit1': {
'value': 5,
'currency': 11,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit2': {
'value': 6,
'currency': 19,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
}
}
}
groups = {}
_combine_grouped_benefits(groups, base_group)
_combine_grouped_benefits(groups, new_group)
target = {
'group1': base_group['group1'],
'group2': new_group['group2']
}
self.assertEqual(groups, target)
def test_combine_benefit_groups_sums_benefits(self):
base_group = {
'group1': {
'benefit1': {
'value': 3,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit2': {
'value': 4,
'currency': 10,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit3': {
'value': 32,
'currency': 919,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
}
}
}
new_group = {
'group1': {
'benefit1': {
'value': 5,
'currency': 11,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit2': {
'value': 7,
'unit': 'gal',
'currency': 19,
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit4': {
'value': 7,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
}
}
}
groups = {}
_combine_grouped_benefits(groups, base_group)
_combine_grouped_benefits(groups, new_group)
target = {
'group1': {
'benefit1': {
'value': 8,
'currency': 11,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit2': {
'value': 11,
'currency': 29,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit3': {
'value': 32,
'currency': 919,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
},
'benefit4': {
'value': 7,
'unit': 'gal',
'label': BenefitCategory.STORMWATER,
'unit-name': 'eco'
}
}
}
self.assertEqual(groups, target)
def test_annotates_basis(self):
basis = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 15
},
'group2': {
'n_objects_used': 2,
'n_objects_discarded': 18
}
}
target = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 15,
'n_total': 20,
'n_pct_calculated': 0.25
},
'group2': {
'n_objects_used': 2,
'n_objects_discarded': 18,
'n_total': 20,
'n_pct_calculated': 0.1
}
}
_annotate_basis_with_extra_stats(basis)
self.assertEqual(basis, target)
def setUp(self):
super(ExportSpeciesTaskTest, self).setUp()
species = Species(common_name='foo', instance=self.instance)
species.save_with_user(self.user)
def make_species(self, otm_code):
species = Species(instance=self.instance, otm_code=otm_code)
species.save_with_user(self.commander)
return species
class EcoTest(UrlTestCase):
def setUp(self):
region = ITreeRegion.objects.get(code='NoEastXXX')
p = region.geometry.point_on_surface
self.instance = make_instance(is_public=True, point=p)
self.user = make_commander_user(self.instance)
self.species = Species(otm_code='CEAT',
genus='cedrus',
species='atlantica',
max_dbh=2000,
max_height=100,
instance=self.instance)
self.species.save_with_user(self.user)
self.plot = Plot(geom=p, instance=self.instance)
self.plot.save_with_user(self.user)
self.tree = Tree(plot=self.plot,
instance=self.instance,
readonly=False,
species=self.species,
diameter=1630)
self.tree.save_with_user(self.user)
def test_group_eco(self):
pass # TODO: Once filtering has been enabled
def assert_benefit_value(self, bens, benefit, unit, value):
self.assertEqual(bens[benefit]['unit'], unit)
self.assertEqual(int(float(bens[benefit]['value'])), value)
def test_eco_benefit_sanity(self):
rslt = tree_benefits(instance=self.instance,
tree_id=self.tree.pk)
bens = rslt['benefits'][0]
self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)
def test_species_for_none_region_lookup(self):
self.assertIsNone(species_codes_for_regions(None))
def test_species_for_region_lookup(self):
northeast = species_codes_for_regions(['NoEastXXX'])
self.assertEqual(258, len(northeast))
south = species_codes_for_regions(['PiedmtCLT'])
self.assertEqual(244, len(south))
combined = species_codes_for_regions(['NoEastXXX', 'PiedmtCLT'])
self.assertEqual(338, len(combined))
combined_set = set(combined)
self.assertEqual(len(combined), len(combined_set),
"Getting the species for more than one region "
"should result in a unique set of otm_codes")
def test_default_region(self):
# move the point outside the eco region
self.plot.geom = Point(0, 0)
self.plot.save_with_user(self.user)
result = tree_benefits(instance=self.instance,
tree_id=self.tree.pk)
bens_wo_default = result['benefits'][0]
self.assert_benefit_value(bens_wo_default, 'energy', 'kwh', 0)
self.assert_benefit_value(bens_wo_default, 'airquality', 'lbs/year', 0)
self.assert_benefit_value(bens_wo_default, 'stormwater', 'gal', 0)
self.assert_benefit_value(bens_wo_default, 'co2', 'lbs/year', 0)
self.instance.itree_region_default = 'NoEastXXX'
self.instance.save()
result = tree_benefits(instance=self.instance,
tree_id=self.tree.pk)
bens_with_default = result['benefits'][0]
self.assert_benefit_value(bens_with_default,
'energy', 'kwh', 1896)
self.assert_benefit_value(bens_with_default,
'airquality', 'lbs/year', 6)
self.assert_benefit_value(bens_with_default,
'stormwater', 'gal', 3185)
self.assert_benefit_value(bens_with_default,
'co2', 'lbs/year', 563)
class EcoTest(UrlTestCase):
def setUp(self):
# Example url for
# CEAT, 1630 dbh, NoEastXXX
# eco.json?otmcode=CEAT&diameter=1630®ion=NoEastXXX
def mockbenefits(*args, **kwargs):
benefits = {
"Benefits": {
"aq_nox_avoided": 0.6792,
"aq_nox_dep": 0.371,
"aq_ozone_dep": 0.775,
"aq_pm10_avoided": 0.0436,
"aq_pm10_dep": 0.491,
"aq_sox_avoided": 0.372,
"aq_sox_dep": 0.21,
"aq_voc_avoided": 0.0254,
"bvoc": -0.077,
"co2_avoided": 255.5,
"co2_sequestered": 0,
"co2_storage": 6575,
"electricity": 187,
"hydro_interception": 12.06,
"natural_gas": 5834.1
}
}
return (benefits, None)
region = ITreeRegion.objects.get(code='NoEastXXX')
p = region.geometry.point_on_surface
self.instance = make_instance(is_public=True, point=p)
self.user = make_commander_user(self.instance)
self.species = Species(otm_code='CEAT',
genus='cedrus',
species='atlantica',
max_dbh=2000,
max_height=100,
instance=self.instance)
self.species.save_with_user(self.user)
self.plot = Plot(geom=p, instance=self.instance)
self.plot.save_with_user(self.user)
self.tree = Tree(plot=self.plot,
instance=self.instance,
readonly=False,
species=self.species,
diameter=1630)
self.tree.save_with_user(self.user)
self.origBenefitFn = ecobackend.json_benefits_call
ecobackend.json_benefits_call = mockbenefits
def tearDown(self):
ecobackend.json_benefits_call = self.origBenefitFn
def assert_benefit_value(self, bens, benefit, unit, value):
self.assertEqual(bens[benefit]['unit'], unit)
self.assertEqual(int(float(bens[benefit]['value'])), value)
def test_eco_benefit_sanity(self):
rslt = tree_benefits(instance=self.instance,
tree_or_tree_id=self.tree)
bens = rslt['tree_benefits']
self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)
def testSearchBenefits(self):
request = make_request(
{'q': json.dumps({'tree.readonly': {'IS': False}})}) # all trees
request.instance_supports_ecobenefits = self.instance\
.has_itree_region()
result = search_tree_benefits(request, self.instance)
benefits = result['tree_benefits']
self.assertTrue(len(benefits) > 0)
def setUp(self):
super(ExportSpeciesTaskTest, self).setUp()
species = Species(common_name='foo', instance=self.instance)
species.save_with_user(self.user)
class EcoTestCase(UrlTestCase):
def setUp(self):
# Example url for
# CEAT, 1630 dbh, NoEastXXX
# eco.json?otmcode=CEAT&diameter=1630®ion=NoEastXXX
def mockbenefits(*args, **kwargs):
benefits = {
"Benefits": {
"aq_nox_avoided": 0.6792,
"aq_nox_dep": 0.371,
"aq_ozone_dep": 0.775,
"aq_pm10_avoided": 0.0436,
"aq_pm10_dep": 0.491,
"aq_sox_avoided": 0.372,
"aq_sox_dep": 0.21,
"aq_voc_avoided": 0.0254,
"bvoc": -0.077,
"co2_avoided": 255.5,
"co2_sequestered": 0,
"co2_storage": 6575,
"electricity": 187,
"hydro_interception": 12.06,
"natural_gas": 5834.1
}
}
return (benefits, None)
region = ITreeRegion.objects.get(code='NoEastXXX')
p = region.geometry.point_on_surface
converter = BenefitCurrencyConversion(currency_symbol='$',
electricity_kwh_to_currency=1.0,
natural_gas_kbtu_to_currency=1.0,
co2_lb_to_currency=1.0,
o3_lb_to_currency=1.0,
nox_lb_to_currency=1.0,
pm10_lb_to_currency=1.0,
sox_lb_to_currency=1.0,
voc_lb_to_currency=1.0,
h20_gal_to_currency=1.0)
converter.save()
self.instance = make_instance(is_public=True, point=p)
self.instance.eco_benefits_conversion = converter
self.instance.save()
self.user = make_commander_user(self.instance)
self.species = Species(otm_code='CEAT',
genus='cedrus',
species='atlantica',
max_diameter=2000,
max_height=100,
instance=self.instance)
self.species.save_with_user(self.user)
self.origBenefitFn = ecobackend.json_benefits_call
ecobackend.json_benefits_call = mockbenefits
def tearDown(self):
ecobackend.json_benefits_call = self.origBenefitFn
def assert_benefit_value(self, bens, benefit, unit, value):
self.assertEqual(bens[benefit]['unit'], unit)
self.assertEqual(int(float(bens[benefit]['value'])), value)
class EcoTest(UrlTestCase):
def setUp(self):
# Example url for
# CEAT, 1630 dbh, NoEastXXX
# eco.json?otmcode=CEAT&diameter=1630®ion=NoEastXXX
def mockbenefits(*args, **kwargs):
benefits = {
"Benefits": {
"aq_nox_avoided": 0.6792,
"aq_nox_dep": 0.371,
"aq_ozone_dep": 0.775,
"aq_pm10_avoided": 0.0436,
"aq_pm10_dep": 0.491,
"aq_sox_avoided": 0.372,
"aq_sox_dep": 0.21,
"aq_voc_avoided": 0.0254,
"bvoc": -0.077,
"co2_avoided": 255.5,
"co2_sequestered": 0,
"co2_storage": 6575,
"electricity": 187,
"hydro_interception": 12.06,
"natural_gas": 5834.1
}
}
return (benefits, None)
region = ITreeRegion.objects.get(code='NoEastXXX')
p = region.geometry.point_on_surface
self.instance = make_instance(is_public=True, point=p)
self.user = make_commander_user(self.instance)
self.species = Species(otm_code='CEAT',
genus='cedrus',
species='atlantica',
max_dbh=2000,
max_height=100,
instance=self.instance)
self.species.save_with_user(self.user)
self.plot = Plot(geom=p, instance=self.instance)
self.plot.save_with_user(self.user)
self.tree = Tree(plot=self.plot,
instance=self.instance,
readonly=False,
species=self.species,
diameter=1630)
self.tree.save_with_user(self.user)
self.origBenefitFn = ecobackend.json_benefits_call
ecobackend.json_benefits_call = mockbenefits
def tearDown(self):
ecobackend.json_benefits_call = self.origBenefitFn
def assert_benefit_value(self, bens, benefit, unit, value):
self.assertEqual(bens[benefit]['unit'], unit)
self.assertEqual(int(float(bens[benefit]['value'])), value)
def test_eco_benefit_sanity(self):
rslt, basis, error = TreeBenefitsCalculator()\
.benefits_for_object(self.instance, self.tree.plot)
bens = rslt['plot']
self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)
def testSearchBenefits(self):
request = make_request(
{'q': json.dumps({'tree.readonly': {'IS': False}})}) # all trees
request.instance_supports_ecobenefits = self.instance\
.has_itree_region()
result = search_tree_benefits(request, self.instance)
benefits = result['benefits']
self.assertTrue(len(benefits) > 0)
def test_group_basis_empty(self):
basis = {}
example = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 8
},
'group2': {
'n_objects_used': 10,
'n_objects_discarded': 12
}
}
_combine_benefit_basis(basis, example)
self.assertEqual(basis, example)
def test_group_basis_combine_new_group(self):
# New groups are added
basis = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 8
}
}
new_group = {
'group2': {
'n_objects_used': 13,
'n_objects_discarded': 4
}
}
target = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 8
},
'group2': {
'n_objects_used': 13,
'n_objects_discarded': 4
}
}
_combine_benefit_basis(basis, new_group)
self.assertEqual(basis, target)
def test_group_basis_combine_existing_groups(self):
basis = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 8
}
}
update_group = {
'group1': {
'n_objects_used': 13,
'n_objects_discarded': 4
}
}
target = {
'group1': {
'n_objects_used': 18,
'n_objects_discarded': 12
}
}
_combine_benefit_basis(basis, update_group)
self.assertEqual(basis, target)
def test_combine_benefit_groups_empty(self):
# with and without currency
base_group = {'group1':
{'benefit1':
{'value': 3,
'currency': 9,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit2':
{'value': 3,
'currency': 9,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'}}}
groups = {}
_combine_grouped_benefits(groups, base_group)
self.assertEqual(groups, base_group)
def test_combine_benefit_groups_no_overlap(self):
base_group = {'group1':
{'benefit1':
{'value': 3,
'currency': 9,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit2':
{'value': 4,
'currency': 10,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'}}}
new_group = {'group2':
{'benefit1':
{'value': 5,
'currency': 11,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit2':
{'value': 6,
'currency': 19,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'}}}
groups = {}
_combine_grouped_benefits(groups, base_group)
_combine_grouped_benefits(groups, new_group)
target = {'group1': base_group['group1'],
'group2': new_group['group2']}
self.assertEqual(groups, target)
def test_combine_benefit_groups_sums_benefits(self):
base_group = {'group1':
{'benefit1':
{'value': 3,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit2':
{'value': 4,
'currency': 10,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit3':
{'value': 32,
'currency': 919,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'}}}
new_group = {'group1':
{'benefit1':
{'value': 5,
'currency': 11,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit2':
{'value': 7,
'unit': 'gal',
'currency': 19,
'label': 'stormwater',
'unit-name': 'eco'},
'benefit4':
{'value': 7,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'}}}
groups = {}
_combine_grouped_benefits(groups, base_group)
_combine_grouped_benefits(groups, new_group)
target = {'group1':
{'benefit1':
{'value': 8,
'currency': 11,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit2':
{'value': 11,
'currency': 29,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit3':
{'value': 32,
'currency': 919,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'},
'benefit4':
{'value': 7,
'unit': 'gal',
'label': 'stormwater',
'unit-name': 'eco'}}}
self.assertEqual(groups, target)
def test_annotates_basis(self):
basis = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 15
},
'group2': {
'n_objects_used': 2,
'n_objects_discarded': 18
}
}
target = {
'group1': {
'n_objects_used': 5,
'n_objects_discarded': 15,
'n_total': 20,
'n_pct_calculated': 0.25
},
'group2': {
'n_objects_used': 2,
'n_objects_discarded': 18,
'n_total': 20,
'n_pct_calculated': 0.1
}
}
_annotate_basis_with_extra_stats(basis)
self.assertEqual(basis, target)
