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 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 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):
        self.instance = make_instance()

        self.user = make_user(username='user')

        self.instance_user = make_user(self.instance, 'instance_user')
        self.client.get('/accounts/logout/')

    def setUp(self):
        self.instance = make_instance()
        datatype = [
            {'type': 'choice', 'choices': ['love', 'hug'], 'name': 'action'},
            {'type': 'int', 'name': 'times'},
            {'type': 'date', 'name': 'day'},
        ]
        create_stewardship_udfs(self.instance)
        make_collection_udf(self.instance, model='Plot', name='Caring',
                            datatype=datatype)
        make_collection_udf(self.instance, model='Tree', name='Caring',
                            datatype=datatype)

        UserDefinedFieldDefinition.objects.create(
            instance=self.instance,
            model_type='Plot',
            datatype=json.dumps({'type': 'string'}),
            iscollection=False,
            name='Name')

        UserDefinedFieldDefinition.objects.create(
            instance=self.instance,
            model_type='Tree',
            datatype=json.dumps({'type': 'int'}),
            iscollection=False,
            name='Man Units')

 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):
     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.instance = make_instance()

        self.user = make_user(username='user', password='user')

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

        self.user_perm, __ = FieldPermission.objects.get_or_create(
            model_name='Plot', field_name='width',
            permission_level=FieldPermission.NONE,
            role=self.role, instance=self.instance)

        iuser = InstanceUser(instance=self.instance, user=self.user,
                             role=self.role)
        iuser.save_with_user(self.user)

        inst_role = Role(name='inst def role',
                         instance=self.instance,
                         rep_thresh=0)
        inst_role.save()

        self.inst_perm, __ = FieldPermission.objects.get_or_create(
            model_name='Plot', field_name='width',
            permission_level=FieldPermission.NONE,
            role=inst_role, instance=self.instance)

        self.instance.default_role = inst_role
        self.instance.save()

        self.plot = Plot(instance=self.instance)

 def test_anonymous_boundary_thumbprint(self):
     make_simple_boundary('n', n=0)
     instance = make_instance()
     thumbprint1 = instance.boundary_thumbprint
     make_anonymous_boundary(n=1)
     thumbprint2 = instance.boundary_thumbprint
     self.assertEqual(thumbprint1, thumbprint2)

 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 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_two_boundary_thumbprint(self):
     make_simple_boundary('n1', n=0)
     instance = make_instance()
     thumbprint1 = instance.boundary_thumbprint
     make_simple_boundary('n2', n=1)
     thumbprint2 = instance.boundary_thumbprint
     self.assertNotEqual(thumbprint1, thumbprint2)

    def setUp(self):
        self.user = make_user(username='test', password='password')
        self.instance = make_instance()

        # Create an admin user to verify that not all admins get notifications
        self.admin = make_user(instance=self.instance, username='admin',
                               admin=True)

 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):
     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 test_boundary_thumbprint(self):
     b = make_simple_boundary('n', n=0)
     instance = make_instance()
     thumbprint1 = instance.boundary_thumbprint
     b.name = 'n1'
     b.save()
     thumbprint2 = instance.boundary_thumbprint
     self.assertNotEqual(thumbprint1, thumbprint2)

 def setUp(self):
     self.instance = make_instance()
     self.user_a = make_plain_user('a', 'a')
     self.user_b = make_plain_user('b', 'b')
     self.plan_a1 = self._make_plan('a1', self.user_a, True)
     self.plan_a2 = self._make_plan('a2', self.user_a, False)
     self.plan_b1 = self._make_plan('b1', self.user_b, True)
     self.plan_b2 = self._make_plan('b2', self.user_b, False)

    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 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