Exemplo n.º 1
0
    def test_update_tree_returns_400_on_invalid_species_id(self):
        test_plot = mkPlot(self.user)
        mkTree(self.user, plot=test_plot)

        invalid_species_id = -1
        self.assertRaises(Exception, Species.objects.get, pk=invalid_species_id)

        updated_values = {'tree': {'species': invalid_species_id}}
        response = put_json( "%s/plots/%d"  % (API_PFX, test_plot.id), updated_values, self.client, self.sign)
        self.assertEqual(400, response.status_code)
        response_json = loads(response.content)
        self.assertTrue("error" in response_json.keys(), "Expected an 'error' key in the JSON response")
Exemplo n.º 2
0
    def test_get_current_tree(self):
        plot = mkPlot(self.user)
        plot_id = plot.pk

        tree = mkTree(self.user, plot=plot)

        response = self.client.get("%s/plots/%d/tree" % (API_PFX, plot_id), **self.sign)
        self.assertEqual(200, response.status_code, "Expected 200 status code after delete")
        response_dict = loads(response.content)
        self.assertTrue('species' in response_dict, 'Expected "species" to be a top level key in the response object')
        self.assertEqual(tree.species.pk, response_dict['species'])
Exemplo n.º 3
0
    def test_update_tree_species(self):
        test_plot = mkPlot(self.user)
        test_tree = mkTree(self.user, plot=test_plot)
        test_tree_id = test_tree.id

        first_species = Species.objects.all()[0]
        updated_values = {'tree': {'species': first_species.id}}
        response = put_json( "%s/plots/%d"  % (API_PFX, test_plot.id), updated_values, self.client, self.sign)
        self.assertEqual(200, response.status_code)
        tree = Tree.objects.get(pk=test_tree_id)
        self.assertIsNotNone(tree)
        self.assertEqual(first_species, tree.species)
Exemplo n.º 4
0
    def test_update_tree(self):
        test_plot = mkPlot(self.user)
        test_tree = mkTree(self.user, plot=test_plot)
        test_tree_id = test_tree.id
        test_tree.dbh = 2.3
        test_tree.save()

        updated_values = {'tree': {'dbh': 3.9}}
        response = put_json( "%s/plots/%d"  % (API_PFX, test_plot.id), updated_values, self.client, self.sign)
        self.assertEqual(200, response.status_code)
        tree = Tree.objects.get(pk=test_tree_id)
        self.assertIsNotNone(tree)
        self.assertEqual(3.9, tree.dbh)
Exemplo n.º 5
0
    def test_approve_plot_pending_with_mutiple_pending_edits(self):
        settings.PENDING_ON = True

        test_plot = mkPlot(self.user)
        test_plot.width = 100
        test_plot.length = 50
        test_plot.save()
        test_tree = mkTree(self.user, plot=test_plot)
        test_tree.dbh = 2.3
        test_tree.save()

        updated_values = {
            "plot_width": 125,
            "plot_length": 25,
            "tree": {
                "dbh": 3.9
            }
        }

        response = put_json( "%s/plots/%d"  % (API_PFX, test_plot.id), updated_values, self.client, self.public_user_sign)
        self.assertEqual(response.status_code, 200, "Non 200 response when updating plot")

        updated_values = {
            "plot_width": 175,
        }

        response = put_json( "%s/plots/%d"  % (API_PFX, test_plot.id), updated_values, self.client, self.public_user_sign)
        self.assertEqual(response.status_code, 200, "Non 200 response when updating plot")

        test_plot = Plot.objects.get(pk=test_plot.pk)
        pending_edit_count = len(list(test_plot.get_active_pends_with_tree_pends()))
        self.assertEqual(4, pending_edit_count, "Expected three pending edits but got %d" % pending_edit_count)

        pend = test_plot.get_active_pends()[0]
        approved_pend_id = pend.id

        response = post_json("%s/pending-edits/%d/approve/"  % (API_PFX, approved_pend_id), None, self.client, self.sign)
        self.assertEqual(response.status_code, 200, "Non 200 response when approving the pend")
        self.assertEqual(2, len(list(test_plot.get_active_pends_with_tree_pends())), "Expected there to be 2 pending edits after approval")

        for plot_pending in PlotPending.objects.all():
            if plot_pending.id == approved_pend_id:
                self.assertEqual('approved', plot_pending.status, 'The status of the approved pend should be "approved"')
            elif plot_pending.field == 'width':
                self.assertEqual('rejected', plot_pending.status, 'The status of the non-approved width pends should be "rejected"')
            else: # plot_pending.id != approved_pend_id and plot_pending.field != 'width'
                self.assertEqual('pending', plot_pending.status, 'The status of plot pends not on the width field should still be "pending"')

        for tree_pending in TreePending.objects.all():
            self.assertEqual('pending', tree_pending.status, 'The status of tree pends should still be "pending"')
Exemplo n.º 6
0
    def test_change_reputation_for_action_with_sub_actions(self):
        plot = mkPlot(self.jim)
        tree = mkTree(self.jim, plot=plot)

        reputation_count = UserReputationAction.objects.count()
        self.assertEqual(0, reputation_count)

        change_reputation_for_user(self.amy, 'edit verified', tree, sub_action='down', change_initiated_by_user=self.jim)

        self.assertEqual(1, UserReputationAction.objects.count())
        reputation_action = UserReputationAction.objects.all()[0]

        self.assertEqual(self.amy.id, reputation_action.user.id)
        self.assertEqual(self.jim.id, reputation_action.originating_user.id)
        self.assertEqual(-10, reputation_action.value)
Exemplo n.º 7
0
    def test_change_reputation_for_action(self):
        plot = mkPlot(self.jim)
        tree = mkTree(self.jim, plot=plot)

        reputation_count = UserReputationAction.objects.count()
        self.assertEqual(0, reputation_count)

        change_reputation_for_user(self.jim, 'add tree', tree)

        self.assertEqual(1, UserReputationAction.objects.count())
        reputation_action = UserReputationAction.objects.all()[0]

        self.assertEqual(self.jim.id, reputation_action.user.id)
        self.assertEqual(self.jim.id, reputation_action.originating_user.id)
        self.assertEqual(25, reputation_action.value)
Exemplo n.º 8
0
    def test_change_reputation_for_action(self):
        plot = mkPlot(self.jim)
        tree = mkTree(self.jim, plot=plot)

        reputation_count = UserReputationAction.objects.count()
        self.assertEqual(0, reputation_count)

        change_reputation_for_user(self.jim, 'add tree', tree)

        self.assertEqual(1, UserReputationAction.objects.count())
        reputation_action = UserReputationAction.objects.all()[0]

        self.assertEqual(self.jim.id, reputation_action.user.id)
        self.assertEqual(self.jim.id, reputation_action.originating_user.id)
        self.assertEqual(25, reputation_action.value)
Exemplo n.º 9
0
    def assert_pending_edit_operation(self, action, original_dbh=2.3, edited_dbh=3.9):
        settings.PENDING_ON = True

        test_plot = mkPlot(self.user)
        test_tree = mkTree(self.user, plot=test_plot)
        test_tree_id = test_tree.id
        test_tree.dbh = original_dbh
        test_tree.save()

        if action == 'approve':
            status_after_action = 'approved'
        elif action == 'reject':
            status_after_action = 'rejected'
        else:
            raise Exception('Action must be "approve" or "reject"')

        self.assertEqual(0, len(Pending.objects.all()), "Expected the test to start with no pending records")

        updated_values = {'tree': {'dbh': edited_dbh}}
        response = put_json( "%s/plots/%d"  % (API_PFX, test_plot.id), updated_values, self.client, self.public_user_sign)
        self.assertEqual(200, response.status_code)
        tree = Tree.objects.get(pk=test_tree_id)
        self.assertIsNotNone(tree)
        self.assertEqual(original_dbh, tree.dbh, "A pend should have been created instead of editing the tree value.")
        self.assertEqual(1, len(TreePending.objects.all()), "Expected 1 pend record for the edited field.")

        pending_edit = TreePending.objects.all()[0]
        self.assertEqual('pending', pending_edit.status, "Expected the status of the Pending to be 'pending'")
        response = post_json("%s/pending-edits/%d/%s/"  % (API_PFX, pending_edit.id, action), None, self.client, self.sign)
        self.assertEqual(200, response.status_code)

        pending_edit = TreePending.objects.get(pk=pending_edit.id)
        self.assertEqual(status_after_action, pending_edit.status, "Expected the status of the Pending to be '%s'" % status_after_action)
        test_tree = Tree.objects.get(pk=test_tree_id)

        if action == 'approve':
            self.assertEqual(edited_dbh, test_tree.dbh, "Expected dbh to have been updated on the Tree")
        elif action == 'reject':
            self.assertEqual(original_dbh, test_tree.dbh, "Expected dbh to NOT have been updated on the Tree")

        response_json = loads(response.content)
        self.assertTrue('tree' in response_json)
        self.assertTrue('dbh' in response_json['tree'])
        if action == 'approve':
            self.assertEqual(edited_dbh, response_json['tree']['dbh'], "Expected dbh to have been updated in the JSON response")
        elif action == 'reject':
            self.assertEqual(original_dbh, response_json['tree']['dbh'], "Expected dbh to NOT have been updated in the JSON response")
Exemplo n.º 10
0
    def test_change_reputation_for_action_with_sub_actions(self):
        plot = mkPlot(self.jim)
        tree = mkTree(self.jim, plot=plot)

        reputation_count = UserReputationAction.objects.count()
        self.assertEqual(0, reputation_count)

        change_reputation_for_user(self.amy,
                                   'edit verified',
                                   tree,
                                   sub_action='down',
                                   change_initiated_by_user=self.jim)

        self.assertEqual(1, UserReputationAction.objects.count())
        reputation_action = UserReputationAction.objects.all()[0]

        self.assertEqual(self.amy.id, reputation_action.user.id)
        self.assertEqual(self.jim.id, reputation_action.originating_user.id)
        self.assertEqual(-10, reputation_action.value)
Exemplo n.º 11
0
    def test_update_tree_with_pending(self):
        settings.PENDING_ON = True

        test_plot = mkPlot(self.user)
        test_tree = mkTree(self.user, plot=test_plot)
        test_tree_id = test_tree.id
        test_tree.dbh = 2.3
        test_tree.save()

        self.assertEqual(0, len(Pending.objects.all()), "Expected the test to start with no pending records")

        updated_values = {'tree': {'dbh': 3.9}}
        response = put_json( "%s/plots/%d"  % (API_PFX, test_plot.id), updated_values, self.client, self.public_user_sign)
        self.assertEqual(200, response.status_code)
        tree = Tree.objects.get(pk=test_tree_id)
        self.assertIsNotNone(tree)
        self.assertEqual(2.3, tree.dbh, "A pend should have been created instead of editing the tree value.")
        self.assertEqual(1, len(TreePending.objects.all()), "Expected 1 pend record for the edited field.")

        response_json = loads(response.content)
        self.assertEqual(1, len(response_json['pending_edits'].keys()), "Expected the json response to have a pending_edits dict with 1 keys")
Exemplo n.º 12
0
    def test_remove_tree(self):
        plot = mkPlot(self.user)
        plot_id = plot.pk

        tree = mkTree(self.user, plot=plot)
        tree_id = tree.pk

        response = self.client.delete("%s/plots/%d/tree" % (API_PFX, plot_id), **self.sign)
        self.assertEqual(200, response.status_code, "Expected 200 status code after delete")
        response_dict = loads(response.content)
        self.assertIsNone(response_dict['tree'], 'Expected a json object response to a None value for "tree" key after the tree is deleted')

        plot = Plot.objects.get(pk=plot_id)
        tree = Tree.objects.get(pk=tree_id)

        self.assertTrue(plot.present, 'Expected "present" to be True after tree is deleted from plot')
        for audit_trail_record in plot.history.all():
            self.assertTrue(audit_trail_record.present, 'Expected "present" to be True for all audit trail records for plot with a deleted tree')

        self.assertFalse(tree.present, 'Expected "present" to be False on tree associated with a deleted plot')
        for audit_trail_record in tree.history.all():
            self.assertFalse(audit_trail_record.present, 'Expected "present" to be False for all audit trail records for tree associated with a deleted plot')
Exemplo n.º 13
0
    def test_remove_plot(self):
        plot = mkPlot(self.user)
        plot_id = plot.pk

        tree = mkTree(self.user, plot=plot)
        tree_id = tree.pk

        response = self.client.delete("%s/plots/%d" % (API_PFX, plot_id), **self.sign)
        self.assertEqual(200, response.status_code, "Expected 200 status code after delete")
        response_dict = loads(response.content)
        self.assertTrue('ok' in response_dict, 'Expected a json object response with a "ok" key')
        self.assertTrue(response_dict['ok'], 'Expected a json object response with a "ok" key set to True')

        plot = Plot.objects.get(pk=plot_id)
        tree = Tree.objects.get(pk=tree_id)

        self.assertFalse(plot.present, 'Expected "present" to be False on a deleted plot')
        for audit_trail_record in plot.history.all():
            self.assertFalse(audit_trail_record.present, 'Expected "present" to be False for all audit trail records for a deleted plot')

        self.assertFalse(tree.present, 'Expected "present" to be False on tree associated with a deleted plot')
        for audit_trail_record in tree.history.all():
            self.assertFalse(audit_trail_record.present, 'Expected "present" to be False for all audit trail records for tree associated with a deleted plot')
Exemplo n.º 14
0
    def test_tree_data(self):
        p = mkPlot(self.u)
        t = mkTree(self.u, plot=p)

        t.species = None
        t.dbh = None
        t.present = True
        t.save()

        info = self.client.get("%s/plots" % API_PFX, **self.sign)

        self.assertEqual(info.status_code, 200)
        
        json = loads(info.content)

        self.assertEqual(len(json), 1)
        record = json[0]

        self.assertEqual(record["tree"]["id"], t.pk)

        t.species = Species.objects.all()[0]
        t.dbh = 11.2
        t.save()

        info = self.client.get("%s/plots" % API_PFX, **self.sign)

        self.assertEqual(info.status_code, 200)
        
        json = loads(info.content)

        self.assertEqual(len(json), 1)
        record = json[0]

        self.assertEqual(record["tree"]["species"], t.species.pk)
        self.assertEqual(record["tree"]["dbh"], t.dbh)
        self.assertEqual(record["tree"]["id"], t.pk)
Exemplo n.º 15
0
    def test_edit_flags(self):
        content_type_p = ContentType(app_label='auth', model='Plot')
        content_type_p.save()

        content_type_t = ContentType(app_label='auth', model='Tree')
        content_type_t.save()

        p = P(codename="change_user",name="change_user",content_type=content_type_p)
        p.save()

        t = P(codename="change_user",name="change_user",content_type=content_type_t)
        t.save()

        ghost = AnonymousUser()

        peon = User(username="******")
        peon.save()
        peon.reputation = Reputation(user=peon)
        peon.reputation.save()

        duke = User(username="******")
        duke.save()
        duke.reputation = Reputation(user=duke)
        duke.reputation.save()

        leroi = User(username="******")
        leroi.active = True
        leroi.save() # double save required for m2m... 
        leroi.reputation = Reputation(user=leroi)
        leroi.user_permissions.add(p)
        leroi.user_permissions.add(t)
        leroi.save()
        leroi.reputation.save()

        p_peon_0 = mkPlot(peon)
        p_peon_1 = mkPlot(peon)
        p_duke_2 = mkPlot(duke)
        
        t_duke_0 = mkTree(duke, plot=p_peon_0)
        t_peon_1 = mkTree(peon, plot=p_peon_1)
        t_duke_2 = mkTree(duke, plot=p_duke_2)

        p_roi_3 = mkPlot(leroi)
        t_roi_3 = mkTree(leroi, plot=p_roi_3)

        plots = [p_peon_0, p_peon_1, p_duke_2, p_roi_3]
        trees = [t_duke_0, t_peon_1, t_duke_2, t_roi_3]
        users = [ghost, peon, duke, leroi]

        def mkd(e, d):
            return { "can_delete": d, "can_edit": e }

        def mkdp(pe, pd, te=None, td=None):
            d = { "plot": mkd(pe,pd) }
            if td != None and te != None:
                d["tree"] = mkd(te, td)

            return d

        #################################
        # A None or Anonymous user can't
        # do anything
        for p in plots:
            self.assertEqual(mkd(False,False), plot_or_tree_permissions(p, ghost))
            self.assertEqual(mkdp(False,False,False,False), plot_permissions(p, ghost))

            self.assertEqual(mkd(False,False), plot_or_tree_permissions(p, None))
            self.assertEqual(mkdp(False,False,False,False), plot_permissions(p, None))

        for t in trees:
            self.assertEqual(mkd(False,False), plot_or_tree_permissions(t, ghost))
            self.assertEqual(mkd(False,False), plot_or_tree_permissions(t, None))

        #################################
        # A user can always delete or edit their own trees and plots
        #
        self.assertEqual(mkd(True,True), plot_or_tree_permissions(p_peon_0, peon))
        self.assertEqual(mkd(True,True), plot_or_tree_permissions(p_peon_1, peon))
        self.assertEqual(mkd(True,True), plot_or_tree_permissions(p_duke_2, duke))

        self.assertEqual(mkd(True,True), plot_or_tree_permissions(t_duke_0, duke))        
        self.assertEqual(mkd(True,True), plot_or_tree_permissions(t_peon_1, peon))        
        self.assertEqual(mkd(True,True), plot_or_tree_permissions(t_duke_2, duke))        

        self.assertEqual(mkd(True,True), plot_or_tree_permissions(p_roi_3, leroi)) 
        self.assertEqual(mkd(True,True), plot_or_tree_permissions(t_roi_3, leroi)) 

        #################################
        # An admin user can always do anything
        #
        for p in plots:
            self.assertEqual(mkd(True,True), plot_or_tree_permissions(p, leroi))
            self.assertEqual(mkdp(True,True,True,True), plot_permissions(p, leroi))

        for t in trees:
            self.assertEqual(mkd(True,True), plot_or_tree_permissions(t, leroi))

        #################################
        # A user can edit other trees but can't delete
        #
        self.assertEqual(mkdp(True,False,True,False), plot_permissions(p_roi_3, duke))

        #################################
        # No one can edit readonly trees
        #
        for p in plots:
            p.readonly = True
            p.save()
        for t in trees:
            t.readonly = True
            t.save()

        for p in plots:
            for u in users:
                self.assertEqual(mkd(False,False), plot_or_tree_permissions(p, u))
                self.assertEqual(mkdp(False,False,False,False), plot_permissions(p, u))

        for t in trees:
            for u in users:
                self.assertEqual(mkd(False,False), plot_or_tree_permissions(t, u))
Exemplo n.º 16
0
    def test_recent_edits(self):
        user = self.u
        p = mkPlot(user)
        p2 = mkPlot(user)
        t3 = mkTree(user)
        acts = ReputationAction.objects.all()

        content_type_p = ContentType(app_label='auth', model='Plot')
        content_type_p.save()

        reputation1 = UserReputationAction(action=acts[0],
                                           user=user,
                                           originating_user=user,
                                           content_type=content_type_p,
                                           object_id=p.pk,
                                           content_object=p,
                                           value=20)
        reputation1.save()

        auth = base64.b64encode("%s:%s" % (user.username,user.username))
        withauth = dict(create_signer_dict(user).items() + [("HTTP_AUTHORIZATION", "Basic %s" % auth)])

        ret = self.client.get("%s/user/%s/edits" % (API_PFX, user.pk), **withauth)
        json = loads(ret.content)
        
        self.assertEqual(len(json), 1) # Just on reputation item
        self.assertEqual(json[0]['plot_id'], p.pk)
        self.assertEqual(json[0]['id'], reputation1.pk)

        reputation2 = UserReputationAction(action=acts[1 % len(acts)],
                                           user=user,
                                           originating_user=user,
                                           content_type=content_type_p,
                                           object_id=p2.pk,
                                           content_object=p2,
                                           value=20)
        reputation2.save()

        ret = self.client.get("%s/user/%s/edits" % (API_PFX, user.pk), **withauth)
        json = loads(ret.content)
        
        self.assertEqual(len(json), 2) # Just on reputation item
        self.assertEqual(json[0]['plot_id'], p2.pk)
        self.assertEqual(json[0]['id'], reputation2.pk)

        self.assertEqual(json[1]['plot_id'], p.pk)
        self.assertEqual(json[1]['id'], reputation1.pk)

        reputation3 = UserReputationAction(action=acts[2 % len(acts)],
                                           user=user,
                                           originating_user=user,
                                           content_type=content_type_p,
                                           object_id=t3.pk,
                                           content_object=t3,
                                           value=20)
        reputation3.save()


        ret = self.client.get("%s/user/%s/edits" % (API_PFX, user.pk), **withauth)
        json = loads(ret.content)
        
        self.assertEqual(len(json), 3) # Just on reputation item
        self.assertEqual(json[0]['plot_id'], t3.plot.pk)
        self.assertEqual(json[0]['id'], reputation3.pk)

        self.assertEqual(json[1]['plot_id'], p2.pk)
        self.assertEqual(json[1]['id'], reputation2.pk)

        self.assertEqual(json[2]['plot_id'], p.pk)
        self.assertEqual(json[2]['id'], reputation1.pk)

        ret = self.client.get("%s/user/%s/edits?offset=1" % (API_PFX, user.pk), **withauth)
        json = loads(ret.content)
        
        self.assertEqual(len(json), 2) # Just on reputation item
        self.assertEqual(json[0]['plot_id'], p2.pk)
        self.assertEqual(json[0]['id'], reputation2.pk)

        self.assertEqual(json[1]['plot_id'], p.pk)
        self.assertEqual(json[1]['id'], reputation1.pk)

        ret = self.client.get("%s/user/%s/edits?offset=2&length=1" % (API_PFX, user.pk), **withauth)
        json = loads(ret.content)
        
        self.assertEqual(len(json), 1) # Just on reputation item
        self.assertEqual(json[0]['plot_id'], p.pk)
        self.assertEqual(json[0]['id'], reputation1.pk)

        ret = self.client.get("%s/user/%s/edits?length=1" % (API_PFX, user.pk), **withauth)
        json = loads(ret.content)
        
        self.assertEqual(len(json), 1) # Just on reputation item
        self.assertEqual(json[0]['plot_id'], t3.plot.pk)
        self.assertEqual(json[0]['id'], reputation3.pk)
        
        reputation1.delete()
        reputation2.delete()
        reputation3.delete()
        content_type_p.delete()                
        p.delete()
        p2.delete()
        t3.delete()