def setUp(self):
        super(UpdatedFieldsTest, self).setUp()

        self.point = Point(-8515941.0, 4953519.0)
        self.instance = make_instance(point=self.point)
        self.user = make_commander_user(self.instance)
        self.fellow = make_commander_user(self.instance, 'other-commander')
        self.plot = Plot(geom=self.point, instance=self.instance)
        self.plot.save_with_user(self.user)
        self.plot.refresh_from_db()
        self.initial_updated = self.plot.updated_at

    def setUp(self):
        self.instance = make_instance()
        self.commander = make_commander_user(self.instance, "comm")

        # Note unicode '⅀' is on purpose
        self.user1 = User(username='estraven', password='estraven',
                          email='[email protected]',
                          organization='org111',
                          first_name='therem', last_name='⅀straven')

        self.user1.save_with_user(self.commander)

        self.user2 = User(username='genly', password='genly',
                          email='[email protected]',
                          first_name='genly', last_name='ai')
        self.user2.save_with_user(self.commander)

        self.user3 = User(username='argaven_xv', password='argaven_xv',
                          email='[email protected]')
        self.user3.save_with_user(self.commander)

        self.user4 = User(username='faxe', password='faxe',
                          email='[email protected]')
        self.user4.save_with_user(self.commander)

        self.factory = RequestFactory()

    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_user_audits(self):
     self.instance = make_instance()
     username = make_commander_user(self.instance).username
     self.assert_template("/users/%s/edits/" % username, "treemap/recent_user_edits.html")
     self.assert_template(
         "/users/%s/edits/?instance_id=%s" % (username, self.instance.id), "treemap/recent_user_edits.html"
     )

    def setUp(self):
        self.p = Point(-8515941.0, 4953519.0)
        self.instances = [
            make_instance(point=self.p),
            make_instance(point=self.p)
        ]
        self.commander_users = [
            make_commander_user(i, username='commander%d' % i.pk)
            for i in self.instances]
        for i in range(len(self.instances)):
            set_write_permissions(self.instances[i], self.commander_users[i],
                                  'Plot', ['udf:Test choice'])
        self.choice_udfds = [
            UserDefinedFieldDefinition.objects.create(
                instance=i,
                model_type='Plot',
                datatype=json.dumps({'type': 'choice',
                                     'choices': ['a', 'b', 'c']}),
                iscollection=False,
                name='Test choice') for i in self.instances]

        self.plots = [
            Plot(geom=self.p, instance=i) for i in self.instances]

        for i in range(len(self.plots)):
            self.plots[i].save_with_user(self.commander_users[i])

        psycopg2.extras.register_hstore(connection.cursor(), globally=True)

    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 setUp(self):
     self.instance = make_instance()
     self.user = make_commander_user(self.instance)
     self.plot = Plot(instance=self.instance, geom=self.instance.center)
     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(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 setUp(self):
     self.p1 = Point(0, 0)
     self.instance = make_instance(point=self.p1)
     self.commander = make_commander_user(self.instance)
     self.parse_dict_value = partial(
         search._parse_dict_value_for_mapping,
         search.PREDICATE_TYPES)

 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(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 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 setUp(self):
        super(AsyncCSVTestCase, self).setUp()
        self.instance = make_instance()
        self.user = make_commander_user(self.instance)

        self.unprivileged_user = User.objects.create_user(username='foo',
                                                          email='[email protected]',
                                                          password='bar')

 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

 def setUp(self):
     super(UpdatedAtTestCase, 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_plot_create(self):
     username = make_commander_user(self.instance).username
     self.client.login(username=username, password="password")
     self.assert_200(
         self.prefix + "plots/",
         "POST",
         json.dumps({"plot.geom": {"x": 270, "y": 45}}),
         content_type="application/json",
     )

    def setUp(self):
        self.instance = make_instance()
        self.commander = make_commander_user(self.instance)

        self.new_role = Role(name='Ambassador', instance=self.instance,
                             rep_thresh=0)
        self.new_role.save()

        self.factory = RequestFactory()

    def setUp(self):
        # Example url for
        # CEAT, 1630 dbh, NoEastXXX
        # eco.json?otmcode=CEAT&diameter=1630&region=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 setUp(self):
        self.p = Point(-8515941.0, 4953519.0)
        self.instance = make_instance(point=self.p)

        self.udf = make_collection_udf(self.instance, "Stewardship")

        self.commander_user = make_commander_user(self.instance)
        set_write_permissions(self.instance, self.commander_user, "Plot", ["udf:Stewardship"])

        self.plot = Plot(geom=self.p, instance=self.instance)
        self.plot.save_with_user(self.commander_user)

    def setUp(self):
        super(UpdatedByTest, self).setUp()
        self.other = make_commander_user(instance=self.instance,
                                         username='other')
        self.default_user = make_user_with_default_role(
            instance=self.instance, username='default')

        self.other.save()
        self.default_user.save()
        self.other.refresh_from_db()
        self.default_user.refresh_from_db()