def make_tree(self, user=None):
user = user or make_commander_user(self.instance)
plot = Plot(geom=self.instance.center, instance=self.instance)
plot.save_with_user(user)
tree = Tree(instance=self.instance, plot=plot)
tree.save_with_user(user)
return tree
def test_delete_tree(self):
plot = Plot(instance=self.instance,
geom=Point(0, 0))
plot.save_with_user(self.user)
tree = Tree(instance=self.instance,
plot=plot)
tree.save_with_user(self.user)
self.assertEqual(Plot.objects.count(), 1)
self.assertEqual(Tree.objects.count(), 1)
self._login_workflow()
self._go_to_plot_detail(plot.pk)
self.select_buttons()
self.assertCantClickDeleteOrCancel()
self.assertEqual(Plot.objects.count(), 1)
self.assertEqual(Tree.objects.count(), 1)
self.delete_begin.click()
self.delete_cancel.click()
self.assertCantClickDeleteOrCancel()
self.assertEqual(Plot.objects.count(), 1)
self.assertEqual(Tree.objects.count(), 1)
self.select_buttons()
self.delete_begin.click()
self.delete_confirm.click()
sleep(DATABASE_COMMIT_DELAY)
self.assertEqual(Plot.objects.count(), 1)
self.assertEqual(Tree.objects.count(), 0)
def setUp(self):
super(ExportTreeTaskTest, self).setUp()
set_write_permissions(self.instance, self.user, "Plot", ["udf:Test choice"])
set_write_permissions(self.instance, self.user, "Tree", ["udf:Test int"])
UserDefinedFieldDefinition.objects.create(
instance=self.instance,
model_type="Plot",
datatype=json.dumps({"type": "choice", "choices": ["a", "b", "c"]}),
iscollection=False,
name="Test choice",
)
UserDefinedFieldDefinition.objects.create(
instance=self.instance,
model_type="Tree",
datatype=json.dumps({"type": "int"}),
iscollection=False,
name="Test int",
)
p = Plot(geom=self.instance.center, instance=self.instance, address_street="123 Main Street")
p.udfs["Test choice"] = "a"
p.save_with_user(self.user)
t = Tree(plot=p, instance=self.instance, diameter=2)
t.udfs["Test int"] = 4
t.save_with_user(self.user)
def test_reject_insert_rejects_updates(self):
new_plot = Plot(geom=self.p1, instance=self.instance)
new_plot.save_with_user(self.pending_user)
insert_audit = Audit.objects.filter(model='Plot')\
.get(field='id')
field_audits = Audit.objects.filter(model='Plot')\
.exclude(field='id')
for audit in field_audits:
approve_or_reject_audit_and_apply(
audit, self.commander_user, approved=True)
approve_or_reject_audit_and_apply(insert_audit,
self.commander_user, False)
# need to refresh the field_audits collection from the db
# because references are broken
# why doesn't this work? why are there 5 values in field_audits_ids?
# field_audit_ids = field_audits.values_list('id', flat=True)
field_audit_ids = [field_audit.id for field_audit in field_audits]
field_audits = Audit.objects.filter(pk__in=field_audit_ids)
for field_audit in field_audits:
attached_review_audit = Audit.objects.get(pk=field_audit.ref.pk)
self.assertEqual(attached_review_audit.action,
Audit.Type.PendingReject)
self.assertNotEqual(None,
Audit.objects.get(
model=field_audit.model,
field=field_audit.field,
model_id=field_audit.model_id,
action=Audit.Type.PendingApprove))
def test_approve_insert_without_required_raises_integrity_error(self):
new_plot = Plot(geom=self.p1, instance=self.instance)
new_plot.save_with_user(self.pending_user)
new_tree = Tree(plot=new_plot,
instance=self.instance,
diameter=10,
height=10,
readonly=False)
new_tree.save_with_user(self.pending_user)
approve_or_reject_audits_and_apply(new_plot.audits(),
self.commander_user, True)
diameter_audit = Audit.objects.get(model='Tree',
field='diameter',
model_id=new_tree.pk)
insert_audit = Audit.objects.get(model='Tree',
model_id=new_tree.pk,
field='id')
approve_or_reject_audit_and_apply(diameter_audit,
self.commander_user,
approved=True)
self.assertRaises(IntegrityError, approve_or_reject_audit_and_apply,
insert_audit, self.commander_user, True)
def setUp(self):
super(ExportTreeTaskTest, self).setUp()
set_write_permissions(self.instance, self.user,
'Plot', ['udf:Test choice'])
set_write_permissions(self.instance, self.user,
'Tree', ['udf:Test int'])
UserDefinedFieldDefinition.objects.create(
instance=self.instance,
model_type='Plot',
datatype=json.dumps({'type': 'choice',
'choices': ['a', 'b', 'c']}),
iscollection=False,
name='Test choice')
UserDefinedFieldDefinition.objects.create(
instance=self.instance,
model_type='Tree',
datatype=json.dumps({'type': 'int'}),
iscollection=False,
name='Test int')
p = Plot(geom=self.instance.center, instance=self.instance,
address_street="123 Main Street")
p.udfs['Test choice'] = 'a'
p.save_with_user(self.user)
t = Tree(plot=p, instance=self.instance, diameter=2)
t.udfs['Test int'] = 4
t.save_with_user(self.user)
def make_tree(self, user=None):
user = user or make_commander_user(self.instance)
plot = Plot(geom=self.instance.center, instance=self.instance)
plot.save_with_user(user)
tree = Tree(instance=self.instance, plot=plot)
tree.save_with_user(user)
return tree
class UpdateTestCase(LocalMediaTestCase):
def setUp(self):
super(UpdateTestCase, self).setUp()
self.image = self.load_resource('tree1.gif')
self.test_start = timezone.now()
self.point = Point(-8515941.0, 4953519.0)
self.instance = make_instance(point=self.point)
self.user = make_commander_user(self.instance)
self.plot = Plot(geom=self.point, instance=self.instance)
self.plot.save_with_user(self.user)
def max_audit_for_model_type(self, models):
if isinstance(models, basestring):
models = [models]
audits = Audit.objects.filter(model__in=models)\
.order_by('-created')
if audits:
return audits[0]
def clear_updated_at(self):
# to_timestamp(0) is the unix epoch 1970-1-1 00:00
execute_sql(
"UPDATE treemap_mapfeature SET updated_at = to_timestamp(0);")
def clear_and_set_and_reload(self):
self.clear_updated_at()
set_map_feature_updated_at()
self.plot.refresh_from_db()
class UpdateTestCase(LocalMediaTestCase):
def setUp(self):
super(UpdateTestCase, self).setUp()
self.image = self.load_resource('tree1.gif')
self.test_start = timezone.now()
self.point = Point(-8515941.0, 4953519.0)
self.instance = make_instance(point=self.point)
self.user = make_commander_user(self.instance)
self.plot = Plot(geom=self.point, instance=self.instance)
self.plot.save_with_user(self.user)
def max_audit_for_model_type(self, models):
if isinstance(models, basestring):
models = [models]
audits = Audit.objects.filter(model__in=models)\
.order_by('-created')
if audits:
return audits[0]
def clear_updated_at(self):
# to_timestamp(0) is the unix epoch 1970-1-1 00:00
execute_sql(
"UPDATE treemap_mapfeature SET updated_at = to_timestamp(0);")
def clear_and_set_and_reload(self):
self.clear_updated_at()
set_map_feature_updated_at()
self.plot.refresh_from_db()
def test_treephoto_dict_to_model(self):
plot = Plot(geom=self.instance.center, instance=self.instance)
plot.save_with_user(self.commander)
tree = Tree(plot=plot, instance=self.instance)
tree.save_with_user(self.commander)
ipath = self.resource_path('tree1.gif')
tp_dict = json.loads(self.treephoto_blob % ipath)
self.assertEqual(TreePhoto.objects.count(), 0)
save_treephoto_blank = self.default_partial(save_treephoto, '')
save_objects(MIGRATION_RULES, "treephoto", [tp_dict], {
'tree': {
1: tree.pk
},
'user': {
1: self.commander.pk
}
}, save_treephoto_blank, self.instance)
self.assertEqual(TreePhoto.objects.count(), 1)
photo = TreePhoto.objects.all()[0]
self.assertIsNotNone(photo.image)
self.assertIsNotNone(photo.thumbnail)
def setUp(self):
super(CommentTestMixin, self).setUp()
self.instance = make_instance()
self.user = make_commander_user(self.instance)
self.admin = make_admin_user(self.instance)
self.plot = Plot(geom=self.instance.center, instance=self.instance)
self.plot.save_with_user(self.user)
def setUp(self):
super(PlotDetailUITestCase, self).setUp()
self.login_workflow()
self.plot = Plot(instance=self.instance, geom=self.instance.center)
self.plot.save_with_user(self.user)
self.assertEqual(Plot.objects.count(), 1)
def test_tree_add_cancel(self):
plot = Plot(instance=self.instance,
geom=Point(0, 0))
plot.save_with_user(self.user)
self._login_workflow()
self._go_to_plot_detail_edit(plot.pk)
add_tree_button = self.driver.find_element_by_id(
'add-tree')
add_tree_button.click()
cancel_edit_button = self.driver.find_element_by_id(
'cancel-edit-plot')
cancel_edit_button.click()
tree_details_div = self.driver.find_element_by_id(
'tree-details')
with self.assertRaises(ElementNotVisibleException):
tree_details_div.click()
self.assertFalse(Tree.objects.filter(plot=plot).exists())
def setUp(self):
self.p = Point(-7615441.0, 5953519.0)
self.instance = make_instance(point=self.p)
self.user = make_commander_user(self.instance)
self.plot = Plot(geom=self.instance.center, instance=self.instance)
def test_record_is_created_when_nullables_are_still_pending(self):
new_plot = Plot(geom=self.p1, instance=self.instance)
new_plot.save_with_user(self.pending_user)
new_tree = Tree(plot=new_plot, instance=self.instance,
diameter=10, height=10, readonly=False)
new_tree.save_with_user(self.pending_user)
approve_or_reject_audits_and_apply(
new_plot.audits(),
self.commander_user, True)
insert_audit = Audit.objects.filter(model='Tree')\
.get(field='id')
field_audits = Audit.objects.filter(model='Tree')\
.filter(field__in=['readonly', 'diameter',
'plot'])
for audit in field_audits:
approve_or_reject_audit_and_apply(
audit, self.commander_user, approved=True)
approve_or_reject_audit_and_apply(insert_audit,
self.commander_user, True)
real_tree = Tree.objects.get(pk=new_tree.pk)
self.assertEqual(real_tree.plot_id, new_plot.pk)
self.assertEqual(real_tree.diameter, 10)
self.assertEqual(real_tree.height, None)
self.assertNotEqual(real_tree.readonly, True)
def setUp(self):
self.instance = make_instance()
self.user = make_commander_user(self.instance)
self.plot = Plot(instance=self.instance, geom=Point(-7615441, 5953519))
self.plot.save_with_user(self.user)
self.tree = Tree(instance=self.instance, plot=self.plot)
self.tree.save_with_user(self.user)
def _setup_tree_and_collection_udf(self):
instance = make_instance()
self.plotstew = make_collection_udf(instance,
model='Plot',
datatype=COLLECTION_UDF_DATATYPE)
self.treestew = make_collection_udf(instance,
model='Tree',
datatype=COLLECTION_UDF_DATATYPE)
commander = make_commander_user(instance)
set_write_permissions(instance, commander, 'Plot', ['udf:Stewardship'])
set_write_permissions(instance, commander, 'Tree', ['udf:Stewardship'])
d1 = {'action': 'prune', 'date': "2014-05-3 00:00:00"}
d2 = {'action': 'water', 'date': "2014-04-29 00:00:00"}
p1 = Point(-7615441.0, 5953519.0)
self.plot = Plot(instance=instance, geom=p1)
self.plot.udfs[self.plotstew.name] = [d1]
self.plot.save_with_user(commander)
self.tree = Tree(instance=instance, plot=self.plot)
self.tree.udfs[self.treestew.name] = [d2]
self.tree.save_with_user(commander)
def test_record_is_created_when_nullables_are_still_pending(self):
new_plot = Plot(geom=self.p1, instance=self.instance)
new_plot.save_with_user(self.pending_user)
new_tree = Tree(plot=new_plot, instance=self.instance,
diameter=10, height=10, readonly=False)
new_tree.save_with_user(self.pending_user)
approve_or_reject_audits_and_apply(
new_plot.audits(),
self.commander_user, True)
insert_audit = Audit.objects.filter(model='Tree')\
.get(field='id')
field_audits = Audit.objects.filter(model='Tree')\
.filter(field__in=['readonly', 'diameter',
'plot'])
for audit in field_audits:
approve_or_reject_audit_and_apply(
audit, self.commander_user, approved=True)
approve_or_reject_audit_and_apply(insert_audit,
self.commander_user, True)
real_tree = Tree.objects.get(pk=new_tree.pk)
self.assertEqual(real_tree.plot_id, new_plot.pk)
self.assertEqual(real_tree.diameter, 10)
self.assertEqual(real_tree.height, None)
self.assertNotEqual(real_tree.readonly, True)
class WritableTest(PermissionsTestCase):
def test_plot_is_writable_if_can_create_tree(self):
self.commander_user = make_commander_user(self.instance)
self.commander_role = \
self.commander_user.get_instance_user(self.instance).role
self.tree_only_user = make_user(self.instance)
self.tree_only_role = self.instance.default_role
content_type = ContentType.objects.get_for_model(Tree)
add_tree_perm = Permission.objects.get(content_type=content_type,
codename='add_tree')
self.tree_only_role.instance_permissions.add(add_tree_perm)
self.tree_only_role.save()
self.p = Point(-8515941.0, 4953519.0)
self.plot = Plot(instance=self.instance, width=12, geom=self.p)
self.plot.save_with_user(self.commander_user)
plot2 = Plot(instance=self.instance, width=12, geom=self.p)
self.assertRaises(AuthorizeException,
plot2.save_with_user,
self.tree_only_user)
self.tree = Tree(instance=self.instance, plot=self.plot)
self.tree.save_with_user(self.tree_only_user)
self.assertTrue(self.tree.user_can_create(self.tree_only_user))
# The plot should be writable if the user can create a tree
self.assertTrue(perms.map_feature_is_writable(
self.tree_only_role,
self.plot))
def assert_plot_length_context_value(self,
user,
name,
value,
template_fn=None):
if template_fn is None:
template_fn = (self._form_template_with_request_user_for
if user else self._form_template_for)
plot = Plot(length=12.3, instance=self.instance)
plot.convert_to_display_units()
template = template_fn('plot.length')
self._write_field_template("{{" + name + "}}")
_TEMPLATES[0]['DIRS'] = [self.template_dir]
with self.settings(TEMPLATES=_TEMPLATES):
content = template.render(
Context({
'request': {
'user': user,
'instance': self.instance
},
'plot': plot
})).strip()
self.assertEqual(content, value)
def handle(self, *args, **options):
""" Create some seed data """
instance, user = self.setup_env(*args, **options)
species_qs = instance.scope_model(Species)
n = options['n']
self.stdout.write("Will create %s plots" % n)
get_prob = lambda option: float(min(100, max(0, option))) / 100.0
tree_prob = get_prob(options['ptree'])
species_prob = get_prob(options['pspecies'])
diameter_prob = get_prob(options['pdiameter'])
max_radius = options['radius']
center_x = instance.center.x
center_y = instance.center.y
import_event = ImportEvent(imported_by=user)
import_event.save()
ct = 0
cp = 0
for i in xrange(0, n):
mktree = random.random() < tree_prob
radius = random.gauss(0.0, max_radius)
theta = random.random() * 2.0 * math.pi
x = math.cos(theta) * radius + center_x
y = math.sin(theta) * radius + center_y
plot = Plot(instance=instance,
geom=Point(x, y),
import_event=import_event)
plot.save_with_user(user)
cp += 1
if mktree:
add_species = random.random() < species_prob
if add_species:
species = random.choice(species_qs)
else:
species = None
add_diameter = random.random() < diameter_prob
if add_diameter:
diameter = 2 + random.random() * 18
else:
diameter = None
tree = Tree(plot=plot,
import_event=import_event,
species=species,
diameter=diameter,
instance=instance)
tree.save_with_user(user)
ct += 1
self.stdout.write("Created %s trees and %s plots" % (ct, cp))
def test_reject_insert_rejects_updates(self):
new_plot = Plot(geom=self.p1, instance=self.instance)
new_plot.save_with_user(self.pending_user)
insert_audit = Audit.objects.filter(model='Plot')\
.get(field='id')
field_audits = Audit.objects.filter(model='Plot')\
.exclude(field='id')
for audit in field_audits:
approve_or_reject_audit_and_apply(
audit, self.commander_user, approved=True)
approve_or_reject_audit_and_apply(insert_audit,
self.commander_user, False)
# need to refresh the field_audits collection from the db
# because references are broken
# why doesn't this work? why are there 5 values in field_audits_ids?
# field_audit_ids = field_audits.values_list('id', flat=True)
field_audit_ids = [field_audit.id for field_audit in field_audits]
field_audits = Audit.objects.filter(pk__in=field_audit_ids)
for field_audit in field_audits:
attached_review_audit = Audit.objects.get(pk=field_audit.ref.pk)
self.assertEqual(attached_review_audit.action,
Audit.Type.PendingReject)
self.assertNotEqual(None,
Audit.objects.get(
model=field_audit.model,
field=field_audit.field,
model_id=field_audit.model_id,
action=Audit.Type.PendingApprove))
def setUp(self):
super(PlotDeleteTest, self).setUp()
self.login_workflow()
self.plot = Plot(instance=self.instance, geom=Point(0, 0))
self.plot.save_with_user(self.user)
self.assertEqual(Plot.objects.count(), 1)
class UserCanDeleteTestCase(OTMTestCase):
def setUp(self):
instance = make_instance()
self.creator_user = make_officer_user(instance)
self.admin_user = make_admin_user(instance)
self.other_user = make_officer_user(instance, username='******')
self.plot = Plot(geom=instance.center, instance=instance)
self.plot.save_with_user(self.creator_user)
self.tree = Tree(plot=self.plot, instance=instance)
self.tree.save_with_user(self.creator_user)
self.rainBarrel = RainBarrel(geom=instance.center, instance=instance,
capacity=5)
self.rainBarrel.save_with_user(self.creator_user)
def assert_can_delete(self, user, deletable, should_be_able_to_delete):
can = deletable.user_can_delete(user)
self.assertEqual(can, should_be_able_to_delete)
def test_user_can_delete(self):
self.assert_can_delete(self.creator_user, self.plot, True)
self.assert_can_delete(self.admin_user, self.plot, True)
self.assert_can_delete(self.other_user, self.plot, False)
self.assert_can_delete(self.creator_user, self.rainBarrel, True)
self.assert_can_delete(self.admin_user, self.rainBarrel, True)
self.assert_can_delete(self.other_user, self.rainBarrel, False)
self.assert_can_delete(self.creator_user, self.tree, True)
self.assert_can_delete(self.admin_user, self.tree, True)
self.assert_can_delete(self.other_user, self.tree, False)
def setUp(self):
super(ExportTreeTaskTest, self).setUp()
set_write_permissions(self.instance, self.user,
'Plot', ['udf:Test choice'])
set_write_permissions(self.instance, self.user,
'Tree', ['udf:Test int'])
UserDefinedFieldDefinition.objects.create(
instance=self.instance,
model_type='Plot',
datatype=json.dumps({'type': 'choice',
'choices': ['a', 'b', 'c']}),
iscollection=False,
name='Test choice')
UserDefinedFieldDefinition.objects.create(
instance=self.instance,
model_type='Tree',
datatype=json.dumps({'type': 'int'}),
iscollection=False,
name='Test int')
p = Plot(geom=self.instance.center, instance=self.instance,
address_street="123 Main Street")
p.udfs['Test choice'] = 'a'
p.save_with_user(self.user)
t = Tree(plot=p, instance=self.instance, diameter=2)
t.udfs['Test int'] = 4
t.save_with_user(self.user)
def test_treephoto_hash_to_model(self):
plot = Plot(geom=Point(0, 0), instance=self.instance)
plot.save_with_user(self.commander)
tree = Tree(plot=plot, instance=self.instance)
tree.save_with_user(self.commander)
ipath = self.resource_path('tree1.gif')
tp_dict = json.loads(self.photo_blob % ipath)
self.assertEqual(TreePhoto.objects.count(), 0)
save_treephoto_blank = partial(save_treephoto, MIGRATION_RULES, '')
hashes_to_saved_objects(
MIGRATION_RULES,
"treephoto", [tp_dict],
{'tree': {1: tree.pk},
'user': {1: self.commander.pk}},
save_treephoto_blank,
self.instance)
self.assertEqual(TreePhoto.objects.count(), 1)
photo = TreePhoto.objects.all()[0]
self.assertIsNotNone(photo.image)
self.assertIsNotNone(photo.thumbnail)
def test_boundary_search(self):
# Unit Square
b1 = Boundary.objects.create(
geom=MultiPolygon(make_simple_polygon(0)),
name='whatever',
category='whatever',
sort_order=1)
# Unit Square translated by (0.2,0.2)
b2 = Boundary.objects.create(
geom=MultiPolygon(make_simple_polygon(0.2)),
name='whatever',
category='whatever',
sort_order=1)
# Unit square translated by (-1,-1)
b3 = Boundary.objects.create(
geom=MultiPolygon(make_simple_polygon(-1)),
name='whatever',
category='whatever',
sort_order=1)
plot1 = Plot(geom=Point(0.9, 0.9), instance=self.instance)
plot2 = Plot(geom=Point(1.1, 1.1), instance=self.instance)
plot3 = Plot(geom=Point(2.5, 2.5), instance=self.instance)
for p in (plot1, plot2, plot3):
p.save_with_user(self.commander)
boundary1_filter = json.dumps({'plot.geom':
{'IN_BOUNDARY': b1.pk}})
plots = search.Filter(boundary1_filter, '', self.instance)\
.get_objects(Plot)
self.assertEqual(
{plot1.pk},
{p.pk
for p in plots})
boundary2_filter = json.dumps({'plot.geom':
{'IN_BOUNDARY': b2.pk}})
plots = search.Filter(boundary2_filter, '', self.instance)\
.get_objects(Plot)
self.assertEqual(
{plot1.pk, plot2.pk},
{p.pk
for p in plots})
boundary3_filter = json.dumps({'plot.geom':
{'IN_BOUNDARY': b3.pk}})
plots = search.Filter(boundary3_filter, '', self.instance)\
.get_objects(Plot)
self.assertEqual(
0, len(plots))
def commit_row(self):
is_valid = self.validate_row()
if not is_valid:
return # not ready to commit
if self.status == TreeImportRow.SUCCESS:
return # nothing changed so no need to commit
# Get our data
data = self.cleaned
self.convert_units(data, {
fields.trees.PLOT_WIDTH:
self.import_event.plot_width_conversion_factor,
fields.trees.PLOT_LENGTH:
self.import_event.plot_length_conversion_factor,
fields.trees.DIAMETER:
self.import_event.diameter_conversion_factor,
fields.trees.TREE_HEIGHT:
self.import_event.tree_height_conversion_factor,
fields.trees.CANOPY_HEIGHT:
self.import_event.canopy_height_conversion_factor
})
plot_id = data.get(self.model_fields.OPENTREEMAP_PLOT_ID, None)
# Check for an existing plot, use it if we're not already:
if plot_id and (self.plot is None or self.plot.pk != plot_id):
plot = Plot.objects.get(pk=plot_id)
elif self.plot is not None:
plot = self.plot
else:
plot = Plot(instance=self.import_event.instance)
self._commit_plot_data(data, plot)
# TREE_PRESENT handling:
# If True, create a tree
# If False, don't create a tree
# If empty or missing, create a tree if a tree field is specified
tree = plot.current_tree()
tree_edited = False
tree_present = data.get(self.model_fields.TREE_PRESENT, None)
if tree_present:
tree_edited = True
if tree is None:
tree = Tree(instance=plot.instance)
if tree_present or tree_present is None:
self._commit_tree_data(data, plot, tree, tree_edited)
self.plot = plot
self.status = TreeImportRow.SUCCESS
self.save()
def setUp(self):
super(ExportTreeTaskTest, self).setUp()
p = Plot(geom=Point(0, 0), instance=self.instance, address_street="123 Main Street")
p.save_with_user(self.user)
t = Tree(plot=p, instance=self.instance, diameter=2)
t.save_with_user(self.user)
def assert_plot_udf_template(self, user, template_text, value):
plot = Plot(length=12.3, instance=self.instance)
plot.udfs["Test choice"] = "b"
template = self._form_template_with_request_user_for("plot.udf:Test choice")
self._write_field_template(template_text)
with self.settings(TEMPLATE_DIRS=(self.template_dir,)):
content = template.render(Context({"request": {"user": user}, "plot": plot})).strip()
self.assertEqual(content, value)
def setUp(self):
super(UserRoleModelPermissionTest, self).setUp()
self.plot = Plot(geom=self.p1, instance=self.instance)
self.plot.save_with_user(self.direct_user)
self.tree = Tree(plot=self.plot, instance=self.instance)
self.tree.save_with_user(self.direct_user)
def setUp(self):
self.point = Point(-8515941.0, 4953519.0)
self.instance = make_instance(point=self.point)
self.user = make_commander_user(self.instance)
self.plot = Plot(geom=self.point, instance=self.instance)
self.plot.save_with_user(self.user)
self.plot = Plot.objects.get(pk=self.plot.pk)
self.initial_updated = self.plot.updated_at
class EcoTest(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.instance, system_user = tm.make_instance_and_system_user()
self.user = User(username="******")
self.user.save_with_user(system_user)
self.user.roles.add(tm.make_commander_role(self.instance))
self.species = Species(symbol='CEDR',
genus='cedrus',
species='atlantica',
max_dbh=2000,
max_height=100)
self.species.save()
p1 = Point(-8515941.0, 4953519.0)
self.plot = Plot(geom=p1,
instance=self.instance,
created_by=self.user)
self.plot.save_with_user(self.user)
self.tree = Tree(plot=self.plot,
instance=self.instance,
readonly=False,
species=self.species,
diameter=1630,
created_by=self.user)
self.tree.save_with_user(self.user)
def test_group_eco(self):
pass # TODO: Once filtering has been enabled
def test_eco_benefit_sanity(self):
req = self.factory.get('/%s/eco/benefit/tree/%s/' %
(self.instance.pk, self.tree.pk))
response = tree_benefits(req,
instance_id=self.instance.pk,
tree_id=self.tree.pk,
region='NoEastXXX')
self.assertEqual(response.status_code, 200)
rslt = json.loads(response.content)
bens = rslt['benefits']
def assertBValue(benefit, unit, value):
self.assertEqual(bens[benefit]['unit'], unit)
self.assertEqual(int(float(bens[benefit]['value'])), value)
assertBValue('energy', 'kwh', 1896)
assertBValue('airquality', 'lbs/year', 6)
assertBValue('stormwater', 'gal', 3185)
assertBValue('co2', 'lbs/year', 563)
class UserCanDeleteTestCase(OTMTestCase):
def setUp(self):
instance = make_instance()
# Fancy name, but no write, create, or delete permissions
instance.default_role.name = Role.ADMINISTRATOR
self.creator_user = make_officer_user(instance)
self.admin_user = make_admin_user(instance)
self.other_user = make_observer_user(instance, username='******')
self.tweaker_user = make_tweaker_user(instance)
self.conjurer_user = make_conjurer_user(instance)
self.plot = Plot(geom=instance.center, instance=instance)
self.plot.save_with_user(self.creator_user)
self.tree = Tree(plot=self.plot, instance=instance)
self.tree.save_with_user(self.creator_user)
self.rainBarrel = RainBarrel(geom=instance.center,
instance=instance,
capacity=5)
self.rainBarrel.save_with_user(self.creator_user)
def assert_can_delete(self, user, deletable, should_be_able_to_delete):
can = deletable.user_can_delete(user)
self.assertEqual(can, should_be_able_to_delete)
def test_user_can_delete(self):
self.assert_can_delete(self.conjurer_user, self.plot, True)
self.assert_can_delete(self.conjurer_user, self.rainBarrel, True)
self.assert_can_delete(self.conjurer_user, self.tree, True)
self.assert_can_delete(self.creator_user, self.plot, True)
self.assert_can_delete(self.creator_user, self.rainBarrel, True)
self.assert_can_delete(self.creator_user, self.tree, True)
self.assert_can_delete(self.admin_user, self.plot, True)
self.assert_can_delete(self.admin_user, self.rainBarrel, True)
self.assert_can_delete(self.admin_user, self.tree, True)
def test_user_cannot_delete(self):
self.assert_can_delete(self.tweaker_user, self.plot, False)
self.assert_can_delete(self.tweaker_user, self.rainBarrel, False)
self.assert_can_delete(self.tweaker_user, self.tree, False)
self.assert_can_delete(self.other_user, self.plot, False)
self.assert_can_delete(self.other_user, self.rainBarrel, False)
self.assert_can_delete(self.other_user, self.tree, False)
def test_admin_cannot_delete_by_flag(self):
instance = self.tree.get_instance()
role = self.admin_user.get_role(instance)
role.instance_permissions.clear()
self.assertTrue(self.admin_user.get_instance_user(instance).admin)
self.assertEqual(role.instance_permissions.count(), 0)
self.assert_can_delete(self.admin_user, self.tree, False)
def setUp(self):
super(UpdateTestCase, self).setUp()
self.image = self.load_resource('tree1.gif')
self.test_start = timezone.now()
self.point = Point(-8515941.0, 4953519.0)
self.instance = make_instance(point=self.point)
self.user = make_commander_user(self.instance)
self.plot = Plot(geom=self.point, instance=self.instance)
self.plot.save_with_user(self.user)
def test_save_new_object_authorized(self):
'''Save two new objects with authorized user, nothing should happen'''
plot = Plot(geom=self.p1, instance=self.instance)
plot.save_with_user(self.officer)
tree = Tree(plot=plot, instance=self.instance)
tree.save_with_user(self.officer)
def create_and_save_with_choice(c, n=1):
plots = []
for i in xrange(n):
plot = Plot(geom=self.p, instance=self.instance)
plot.udfs['Test choice'] = c
plot.save_with_user(self.commander_user)
plots.append(plot)
return {plot.pk for plot in plots}
def test_save_new_object_unauthorized(self):
plot = Plot(geom=self.p1, instance=self.instance)
self.assertRaises(AuthorizeException, plot.save_with_user, self.outlaw)
plot.save_base()
tree = Tree(plot=plot, instance=self.instance)
self.assertRaises(AuthorizeException, tree.save_with_user, self.outlaw)
def test_save_new_object_authorized(self):
'''Save two new objects with authorized user, nothing should happen'''
plot = Plot(geom=self.p1, instance=self.instance)
plot.save_with_user(self.officer)
tree = Tree(plot=plot, instance=self.instance)
tree.save_with_user(self.officer)
class UserCanDeleteTestCase(OTMTestCase):
def setUp(self):
instance = make_instance()
# Fancy name, but no write, create, or delete permissions
instance.default_role.name = Role.ADMINISTRATOR
self.creator_user = make_officer_user(instance)
self.admin_user = make_admin_user(instance)
self.other_user = make_observer_user(instance, username='******')
self.tweaker_user = make_tweaker_user(instance)
self.conjurer_user = make_conjurer_user(instance)
self.plot = Plot(geom=instance.center, instance=instance)
self.plot.save_with_user(self.creator_user)
self.tree = Tree(plot=self.plot, instance=instance)
self.tree.save_with_user(self.creator_user)
self.rainBarrel = RainBarrel(geom=instance.center, instance=instance,
capacity=5)
self.rainBarrel.save_with_user(self.creator_user)
def assert_can_delete(self, user, deletable, should_be_able_to_delete):
can = deletable.user_can_delete(user)
self.assertEqual(can, should_be_able_to_delete)
def test_user_can_delete(self):
self.assert_can_delete(self.conjurer_user, self.plot, True)
self.assert_can_delete(self.conjurer_user, self.rainBarrel, True)
self.assert_can_delete(self.conjurer_user, self.tree, True)
self.assert_can_delete(self.creator_user, self.plot, True)
self.assert_can_delete(self.creator_user, self.rainBarrel, True)
self.assert_can_delete(self.creator_user, self.tree, True)
self.assert_can_delete(self.admin_user, self.plot, True)
self.assert_can_delete(self.admin_user, self.rainBarrel, True)
self.assert_can_delete(self.admin_user, self.tree, True)
def test_user_cannot_delete(self):
self.assert_can_delete(self.tweaker_user, self.plot, False)
self.assert_can_delete(self.tweaker_user, self.rainBarrel, False)
self.assert_can_delete(self.tweaker_user, self.tree, False)
self.assert_can_delete(self.other_user, self.plot, False)
self.assert_can_delete(self.other_user, self.rainBarrel, False)
self.assert_can_delete(self.other_user, self.tree, False)
def test_admin_cannot_delete_by_flag(self):
instance = self.tree.get_instance()
role = self.admin_user.get_role(instance)
role.instance_permissions.clear()
self.assertTrue(self.admin_user.get_instance_user(instance).admin)
self.assertEqual(role.instance_permissions.count(), 0)
self.assert_can_delete(self.admin_user, self.tree, False)
def mkPlot(u, geom=Point(50, 50)):
p = Plot(geometry=geom,
last_updated_by=u,
import_event=ImportEvent.objects.all()[0],
present=True,
data_owner=u)
p.save()
return p
class CommentTestMixin(object):
# A mixin class for comment tests, sets up some non-comment related data
def setUp(self):
super(CommentTestMixin, self).setUp()
self.instance = make_instance()
self.user = make_commander_user(self.instance)
self.admin = make_admin_user(self.instance)
self.plot = Plot(geom=self.instance.center, instance=self.instance)
self.plot.save_with_user(self.user)
class CommentTestMixin(object):
# A mixin class for comment tests, sets up some non-comment related data
def setUp(self):
super(CommentTestMixin, self).setUp()
self.instance = make_instance()
self.user = make_commander_user(self.instance)
self.admin = make_admin_user(self.instance)
self.plot = Plot(geom=self.instance.center, instance=self.instance)
self.plot.save_with_user(self.user)
def create_and_save_with_choice(c, n=1):
plots = []
for i in xrange(n):
plot = Plot(geom=self.p, instance=self.instance)
plot.udfs['Test choice'] = c
plot.save_with_user(self.commander_user)
plots.append(plot)
return {plot.pk for plot in plots}
def commit_row(self):
is_valid = self.validate_row()
if not is_valid:
return # not ready to commit
if self.status == TreeImportRow.SUCCESS:
return # nothing changed so no need to commit
# Get our data
data = self.cleaned
self.convert_units(
data, {
fields.trees.PLOT_WIDTH:
self.import_event.plot_width_conversion_factor,
fields.trees.PLOT_LENGTH:
self.import_event.plot_length_conversion_factor,
fields.trees.DIAMETER:
self.import_event.diameter_conversion_factor,
fields.trees.TREE_HEIGHT:
self.import_event.tree_height_conversion_factor,
fields.trees.CANOPY_HEIGHT:
self.import_event.canopy_height_conversion_factor
})
plot_id = data.get(self.model_fields.OPENTREEMAP_PLOT_ID, None)
# Check for an existing plot, use it if we're not already:
if plot_id and (self.plot is None or self.plot.pk != plot_id):
plot = Plot.objects.get(pk=plot_id)
elif self.plot is not None:
plot = self.plot
else:
plot = Plot(instance=self.import_event.instance)
self._commit_plot_data(data, plot)
# TREE_PRESENT handling:
# If True, create a tree
# If False, don't create a tree
# If empty or missing, create a tree if a tree field is specified
tree = plot.current_tree()
tree_edited = False
tree_present = data.get(self.model_fields.TREE_PRESENT, None)
if tree_present:
tree_edited = True
if tree is None:
tree = Tree(instance=plot.instance)
if tree_present or tree_present is None:
self._commit_tree_data(data, plot, tree, tree_edited)
self.plot = plot
self.status = TreeImportRow.SUCCESS
self.save()
def handle(self, *args, **options):
""" Create some seed data """
instance, user = self.setup_env(*args, **options)
species_qs = instance.scope_model(Species)
n = options['n']
self.stdout.write("Will create %s plots" % n)
get_prob = lambda option: float(min(100, max(0, option))) / 100.0
tree_prob = get_prob(options['ptree'])
species_prob = get_prob(options['pspecies'])
diameter_prob = get_prob(options['pdiameter'])
max_radius = options['radius']
center_x = instance.center.x
center_y = instance.center.y
ct = 0
cp = 0
for i in xrange(0, n):
mktree = random.random() < tree_prob
radius = random.gauss(0.0, max_radius)
theta = random.random() * 2.0 * math.pi
x = math.cos(theta) * radius + center_x
y = math.sin(theta) * radius + center_y
plot = Plot(instance=instance,
geom=Point(x, y))
plot.save_with_user(user)
cp += 1
if mktree:
add_species = random.random() < species_prob
if add_species:
species = random.choice(species_qs)
else:
species = None
add_diameter = random.random() < diameter_prob
if add_diameter:
diameter = 2 + random.random() * 18
else:
diameter = None
tree = Tree(plot=plot,
species=species,
diameter=diameter,
instance=instance)
tree.save_with_user(user)
ct += 1
instance.update_geo_rev()
self.stdout.write("Created %s trees and %s plots" % (ct, cp))
def test_count_is_cached(self):
count = get_cached_plot_count(self.filter)
self.assertEqual(0, count)
# We save with the old
plot = Plot(geom=self.instance.center, instance=self.instance)
plot.save_with_user(self.user)
count = get_cached_plot_count(self.filter)
self.assertEqual(0, count)
def test_updating_geo_rev_busts_count_cache(self):
count = get_cached_plot_count(self.filter)
self.assertEqual(0, count)
plot = Plot(geom=self.instance.center, instance=self.instance)
plot.save_with_user(self.user)
self.filter.instance.update_geo_rev()
count = get_cached_plot_count(self.filter)
self.assertEqual(1, count)
def mkPlot(instance, user, geom=None):
if geom is None:
geom = instance.center
elif geom.srs.srid != 3857:
geom.transform(3857)
p = Plot(geom=geom, instance=instance)
p.save_with_user(user)
return p
def mkPlot(instance, user, geom=None):
if geom is None:
geom = instance.center
elif geom.srs.srid != 3857:
geom.transform(3857)
p = Plot(geom=geom, instance=instance)
p.save_with_user(user)
return p
def mkPlot(u, geom=Point(50, 50)):
p = Plot(
geometry=geom,
last_updated_by=u,
import_event=ImportEvent.objects.all()[0],
present=True,
data_owner=u)
p.save()
return p
def setUp(self):
self.p1 = Point(-7615441.0, 5953519.0)
self.instance = make_instance(point=self.p1)
self.commander_user = make_commander_user(self.instance)
self.direct_user = make_officer_user(self.instance)
self.pending_user = make_apprentice_user(self.instance)
self.observer_user = make_observer_user(self.instance)
self.plot = Plot(geom=self.p1, instance=self.instance, length=5.0)
self.plot.save_with_user(self.commander_user)
def test_updating_geo_rev_busts_count_cache(self):
count = get_cached_plot_count(self.filter)
self.assertEqual(0, count)
plot = Plot(geom=self.instance.center, instance=self.instance)
plot.save_with_user(self.user)
self.filter.instance.update_geo_rev()
count = get_cached_plot_count(self.filter)
self.assertEqual(1, count)
def test_count_is_cached(self):
count = get_cached_plot_count(self.filter)
self.assertEqual(0, count)
# We save with the old
plot = Plot(geom=self.instance.center, instance=self.instance)
plot.save_with_user(self.user)
count = get_cached_plot_count(self.filter)
self.assertEqual(0, count)
def setUp(self):
point = Point(-8515941.0, 4953519.0)
instance = make_instance(point=point)
user = make_commander_user(instance)
plot = Plot(geom=point, instance=instance)
plot.save_with_user(user)
self.user = user
self.instance = instance
self.plot_obj = Plot.objects.get(instance=instance)
self.map_feature_obj = MapFeature.objects.get(instance=instance)
def assert_plot_udf_template(self, user, template_text, value):
plot = Plot(length=12.3, instance=self.instance)
plot.udfs['Test choice'] = 'b'
template = self._form_template_with_request_user_for(
'plot.udf:Test choice')
self._write_field_template(template_text)
with self.settings(TEMPLATE_DIRS=(self.template_dir,)):
content = template.render(Context({
'request': {'user': user},
'plot': plot})).strip()
self.assertEqual(content, value)
class MultiUserTestCase(OTMTestCase):
def setUp(self):
self.p1 = Point(-7615441.0, 5953519.0)
self.instance = make_instance(point=self.p1)
self.commander_user = make_commander_user(self.instance)
self.direct_user = make_officer_user(self.instance)
self.pending_user = make_apprentice_user(self.instance)
self.observer_user = make_observer_user(self.instance)
self.plot = Plot(geom=self.p1, instance=self.instance)
self.plot.save_with_user(self.commander_user)
def test_save_new_object_unauthorized_tweaker(self):
plot = Plot(geom=self.p1, instance=self.instance)
self.assertRaises(AuthorizeException,
plot.save_with_user, self.tweaker_user)
plot.save_base()
tree = Tree(plot=plot, instance=self.instance)
self.assertRaises(AuthorizeException,
tree.save_with_user, self.tweaker_user)
def test_allows_cudf(self):
plot, tree = self.create_tree_and_plot()
empty_plot = Plot(geom=self.p1, instance=self.instance)
empty_plot.save_with_user(self.commander)
plots = search.Filter('', '["Plot"]', self.instance)\
.get_objects(Plot)
ids = {p.pk for p in plots}
self.assertEqual(ids, {plot.pk, empty_plot.pk})
def test_plot_with_tree_always_shows_tree_details(self):
plot = Plot(instance=self.instance, geom=self.instance.center)
plot.save_with_user(self.user)
tree = Tree(plot=plot, diameter=10, instance=self.instance)
tree.save_with_user(self.user)
self.login_workflow()
self.go_to_feature_detail(plot.pk)
self._select_elements()
self.edit_plot.click()
self.cancel_edit.click()
self.assertElementVisibility(self.tree_details_section, visible=True)
