示例#1
0
 def test_make_stats_finds_all_years(self):
     year2000 = LobbyistAnnumFactory.create(year=2000)
     CompensationFactory(annum=year2000,
                         interest=self.interest,
                         amount_low=2000,
                         amount_guess=2000,
                         amount_high=2000)
     year2000b = LobbyistAnnumFactory.create(year=2000)
     CompensationFactory(annum=year2000b,
                         interest=self.interest,
                         amount_low=2000,
                         amount_guess=2000,
                         amount_high=2000)
     year2001 = LobbyistAnnumFactory.create(year=2001)
     CompensationFactory(annum=year2001,
                         interest=self.interest,
                         amount_low=2001,
                         amount_guess=2001,
                         amount_high=2001)
     year2004 = LobbyistAnnumFactory.create(year=2004)
     CompensationFactory(annum=year2004,
                         interest=self.interest,
                         amount_low=2004,
                         amount_guess=2004,
                         amount_high=2004)
     with self.assertNumQueries(20):
         self.interest.make_stats()
     # assert stats are generated
     self.assertFalse(self.interest.stats.filter(year=1999).exists())
     self.assertTrue(self.interest.stats.filter(year=2000).exists())
     self.assertTrue(self.interest.stats.filter(year=2001).exists())
     self.assertFalse(self.interest.stats.filter(year=2002).exists())
     self.assertFalse(self.interest.stats.filter(year=2003).exists())
     self.assertTrue(self.interest.stats.filter(year=2004).exists())
     self.assertFalse(self.interest.stats.filter(year=2005).exists())
示例#2
0
    def test_interest_compensation_report_queryset(self):
        """Get a list of `Interest`s sorted by their bankroll of `Lobbyist`s."""
        YEAR = 2000

        for i in range(10):
            LobbyistFactory.create()
            InterestFactory.create()
            InterestFactory.create()

        for i in Interest.objects.all():
            lobbyist = Lobbyist.objects.all().order_by('?')[0]
            try:
                annum = LobbyistAnnum.objects.get(lobbyist=lobbyist, year=YEAR)
            except LobbyistAnnum.DoesNotExist:
                annum = LobbyistAnnumFactory.create(lobbyist=lobbyist,
                                                    year=YEAR)
            CompensationFactory(annum=annum, interest=i)
            # denormalize interest stats
            i.make_stats_for_year(YEAR)

        # use `__exact`, django ORM attempts to evaluate __year as a date lookup
        for stat in InterestStats.objects.filter(
                year__exact=YEAR).order_by('-guess'):
            # print stat
            stat
示例#3
0
    def test_model_relations_api(self):
        """Test the calls used to move between the relations for the models."""
        i = InterestFactory()
        lobbyist = LobbyistFactory.create()
        YEAR = 2000

        try:
            # add an `Interest` to a `Lobbyist`
            annum = LobbyistAnnumFactory.create(lobbyist=lobbyist, year=YEAR)
            CompensationFactory.create(annum=annum, interest=i)

            # get all the `Interest`s for a `Lobbyist`
            Interest.objects.filter(compensation__annum__lobbyist=lobbyist)

            # get all the `Interest`s for a `Lobbyist` by year
            for year in lobbyist.years.all():
                year.clients.all()

            # get all the `Interest`s for a `Lobbyist` for a year
            lobbyist.years.get(year=YEAR).clients.all()

            # get all the `Lobbyist`s for an `Interest`
            i.years_available.all().values('lobbyist')

            # get all the `Lobbyist`s for an `Interest` for a year
            i.years_available.filter(year=YEAR).values('lobbyist')

        except Exception as e:
            self.fail("Ha ha, %s" % e)
示例#4
0
    def test_lobbyist_compensation_relation_api(self):
        """More tests about getting between `Lobbyist`s and `Compensation`."""
        # Make a `Lobbyist` with NUM_CLIENTS clients.
        NUM_CLIENTS = 3
        lobbyist = LobbyistFactory.create()
        annum = LobbyistAnnumFactory.create(lobbyist=lobbyist)
        for x in range(0, NUM_CLIENTS):
            CompensationFactory(annum=annum)

        try:
            # number of years of data we have for a lobbyist
            self.assertEqual(lobbyist.years.count(), 1)
            # number of clients a lobbyist had that year
            self.assertEqual(annum.clients.count(), NUM_CLIENTS)
            self.assertEqual(annum.compensation_set.count(), NUM_CLIENTS)
            # make sure we can .annotate income onto the queryset
            for year in lobbyist.years.all().annotate(
                    income=Sum('compensation__amount_guess')):
                income = 0
                for compensation in year.compensation_set.all():
                    income += compensation.amount_guess
                self.assertEqual(income, year.income)

        except Exception as e:
            self.fail("Ha ha, %s" % e)
示例#5
0
    def test_model_relations_api(self):
        """Test the calls used to move between the relations for the models."""
        i = InterestFactory()
        lobbyist = LobbyistFactory.create()
        YEAR = 2000

        try:
            # add an `Interest` to a `Lobbyist`
            annum = LobbyistAnnumFactory.create(lobbyist=lobbyist, year=YEAR)
            CompensationFactory.create(annum=annum, interest=i)

            # get all the `Interest`s for a `Lobbyist`
            Interest.objects.filter(compensation__annum__lobbyist=lobbyist)

            # get all the `Interest`s for a `Lobbyist` by year
            for year in lobbyist.years.all():
                year.clients.all()

            # get all the `Interest`s for a `Lobbyist` for a year
            lobbyist.years.get(year=YEAR).clients.all()

            # get all the `Lobbyist`s for an `Interest`
            i.years_available.all().values('lobbyist')

            # get all the `Lobbyist`s for an `Interest` for a year
            i.years_available.filter(year=YEAR).values('lobbyist')

        except Exception as e:
            self.fail("Ha ha, %s" % e)
示例#6
0
    def test_lobbyist_compensation_relation_api(self):
        """More tests about getting between `Lobbyist`s and `Compensation`."""
        # Make a `Lobbyist` with NUM_CLIENTS clients.
        NUM_CLIENTS = 3
        lobbyist = LobbyistFactory.create()
        annum = LobbyistAnnumFactory.create(lobbyist=lobbyist)
        for x in range(0, NUM_CLIENTS):
            CompensationFactory(annum=annum)

        try:
            # number of years of data we have for a lobbyist
            self.assertEqual(lobbyist.years.count(), 1)
            # number of clients a lobbyist had that year
            self.assertEqual(annum.clients.count(), NUM_CLIENTS)
            self.assertEqual(annum.compensation_set.count(), NUM_CLIENTS)
            # make sure we can .annotate income onto the queryset
            for year in lobbyist.years.all().annotate(
                    income=Sum('compensation__amount_guess')):
                income = 0
                for compensation in year.compensation_set.all():
                    income += compensation.amount_guess
                self.assertEqual(income, year.income)

        except Exception as e:
            self.fail("Ha ha, %s" % e)
示例#7
0
    def test_make_stats_for_year_takes_aliases_into_account(self):
        """
        This is just like test_make_stats_for_year_is_accurate, except we
        spread the lobbyists to a pool of interests that are all really the
        same interest.
        """
        num_lobbyists = random.randint(7, 13)
        num_interests = random.randint(2, 3)

        # assert we started off with 1 `Interest` (self.interest)
        self.assertEqual(Interest.objects.count(), 1)
        for i in range(num_interests):
            InterestFactory(canonical=self.interest)
        # sanity check
        self.assertEqual(self.interest.aliases.count(), num_interests)

        # associate num_lobbyists `Lobbyist`s with it through `LobbyistAnnum`
        for i in range(num_lobbyists):
            year = LobbyistAnnumFactory.create(year=self.year)
            interest = Interest.objects.all().order_by('?')[0]
            CompensationFactory(annum=year, interest=interest,
                amount_guess=i, amount_high=i * 2, amount_low=0)
        with self.assertNumQueries(5):
            # 1 to get the stats
            # 1 to GET
            # 1 to INSERT
            # 2 for transaction management
            self.interest.make_stats_for_year(self.year)

        stat = self.interest.stats.all().get(year=self.year)
        self.assertEqual(stat.guess, num_lobbyists * (num_lobbyists - 1) / 2)  # math!
        self.assertEqual(stat.high, num_lobbyists * (num_lobbyists - 1))
        self.assertEqual(stat.low, 0)
示例#8
0
    def test_make_stats_for_year_works_with_duplicate_lobbyists(self):
        """
        When a lobbyist lists two clients that are actually the same, they may
        get combined. The lobbyist's compensation should be counted twice.
        """
        num_interests = 4

        # assert we started off with 1 `Interest` (self.interest)
        self.assertEqual(Interest.objects.count(), 1)
        for __ in range(num_interests):
            InterestFactory(canonical=self.interest)
        # sanity check
        self.assertEqual(self.interest.aliases.count(), num_interests)
        self.assertEqual(Interest.objects.count(), num_interests + 1)

        # assign the same lobbyist to all of them
        lobbyist = LobbyistFactory()
        annum = LobbyistAnnumFactory(lobbyist=lobbyist, year=self.year)
        for idx, interest in enumerate(Interest.objects.all()):
            CompensationFactory(annum=annum,
                                interest=interest,
                                amount_guess=idx,
                                amount_high=idx * 2,
                                amount_low=0)
        with self.assertNumQueries(5):
            # 1 to get the stats
            # 1 to GET
            # 1 to INSERT
            # 2 for transaction management
            self.interest.make_stats_for_year(self.year)

        stat = self.interest.stats.all().get(year=self.year)
        self.assertEqual(stat.guess, num_interests * (num_interests + 1) / 2)
        self.assertEqual(stat.high, num_interests * (num_interests + 1))
        self.assertEqual(stat.low, 0)
示例#9
0
 def test_make_stats_for_year_does_nothing_for_noncanonical_interests(self):
     interest = InterestFactory(canonical=self.interest)
     year2000 = LobbyistAnnumFactory.create(year=2000)
     CompensationFactory(annum=year2000, interest=interest,
         amount_low=2000, amount_guess=2000, amount_high=2000)
     interest.make_stats_for_year(2000)
     # assert noncanonical interest did not have stats generated
     self.assertEqual(0, interest.stats.count())
     # assert canonical interest got the stats instead
     self.assertEqual(1, self.interest.stats.count())
示例#10
0
    def test_make_stats_for_year_does_not_pick_up_other_years(self):
        N = 10

        # associate N `Lobbyist`s with it through `LobbyistAnnum`
        for i in range(N):
            annum = LobbyistAnnumFactory.create(year=self.year)
            CompensationFactory.create(annum=annum, interest=self.interest,
                amount_guess=i, amount_high=i * 2, amount_low=0)
        self.interest.make_stats_for_year(self.year)

        # attempt to poison stats with extra data
        for i in range(N)[::2]:
            annum = LobbyistAnnumFactory.create(year=self.year + 1)
            CompensationFactory.create(annum=annum, interest=self.interest)
        self.interest.make_stats_for_year(self.year + 1)

        stat = self.interest.stats.all().get(year=self.year)
        self.assertEqual(stat.guess, N * (N - 1) / 2)  # math!
        self.assertEqual(stat.high, N * (N - 1))
        self.assertEqual(stat.low, 0)
示例#11
0
 def test_make_stats_for_year_does_nothing_for_noncanonical_interests(self):
     interest = InterestFactory(canonical=self.interest)
     year2000 = LobbyistAnnumFactory.create(year=2000)
     CompensationFactory(annum=year2000,
                         interest=interest,
                         amount_low=2000,
                         amount_guess=2000,
                         amount_high=2000)
     interest.make_stats_for_year(2000)
     # assert noncanonical interest did not have stats generated
     self.assertEqual(0, interest.stats.count())
     # assert canonical interest got the stats instead
     self.assertEqual(1, self.interest.stats.count())
示例#12
0
 def test_make_stats_finds_all_years(self):
     year2000 = LobbyistAnnumFactory.create(year=2000)
     CompensationFactory(annum=year2000, interest=self.interest,
         amount_low=2000, amount_guess=2000, amount_high=2000)
     year2000b = LobbyistAnnumFactory.create(year=2000)
     CompensationFactory(annum=year2000b, interest=self.interest,
         amount_low=2000, amount_guess=2000, amount_high=2000)
     year2001 = LobbyistAnnumFactory.create(year=2001)
     CompensationFactory(annum=year2001, interest=self.interest,
         amount_low=2001, amount_guess=2001, amount_high=2001)
     year2004 = LobbyistAnnumFactory.create(year=2004)
     CompensationFactory(annum=year2004, interest=self.interest,
         amount_low=2004, amount_guess=2004, amount_high=2004)
     with self.assertNumQueries(20):
         self.interest.make_stats()
     # assert stats are generated
     self.assertFalse(self.interest.stats.filter(year=1999).exists())
     self.assertTrue(self.interest.stats.filter(year=2000).exists())
     self.assertTrue(self.interest.stats.filter(year=2001).exists())
     self.assertFalse(self.interest.stats.filter(year=2002).exists())
     self.assertFalse(self.interest.stats.filter(year=2003).exists())
     self.assertTrue(self.interest.stats.filter(year=2004).exists())
     self.assertFalse(self.interest.stats.filter(year=2005).exists())
示例#13
0
    def test_make_stats_for_year_does_not_pick_up_other_years(self):
        N = 10

        # associate N `Lobbyist`s with it through `LobbyistAnnum`
        for i in range(N):
            annum = LobbyistAnnumFactory.create(year=self.year)
            CompensationFactory.create(annum=annum,
                                       interest=self.interest,
                                       amount_guess=i,
                                       amount_high=i * 2,
                                       amount_low=0)
        self.interest.make_stats_for_year(self.year)

        # attempt to poison stats with extra data
        for i in range(N)[::2]:
            annum = LobbyistAnnumFactory.create(year=self.year + 1)
            CompensationFactory.create(annum=annum, interest=self.interest)
        self.interest.make_stats_for_year(self.year + 1)

        stat = self.interest.stats.all().get(year=self.year)
        self.assertEqual(stat.guess, N * (N - 1) / 2)  # math!
        self.assertEqual(stat.high, N * (N - 1))
        self.assertEqual(stat.low, 0)
示例#14
0
    def test_lobbyist_compensation_report_queryset(self):
        """Get a list of `Lobbyist`s sorted by their paycheck."""
        NUM_CLIENTS = 3
        YEAR = 2000

        for i in range(10):
            lobbyist = LobbyistFactory.create()
            annum = LobbyistAnnumFactory.create(lobbyist=lobbyist, year=YEAR)
            for x in range(0, NUM_CLIENTS):
                CompensationFactory(annum=annum)

        # Here's a queryset to get the best paid `Lobbyist`s in a year
        qs = LobbyistAnnum.objects.filter(year=YEAR).annotate(
            income=Sum('compensation__amount_guess')).order_by('-income')
        for year in qs:
            # print year.lobbyist, year.income
            year
示例#15
0
    def test_lobbyist_compensation_report_queryset(self):
        """Get a list of `Lobbyist`s sorted by their paycheck."""
        NUM_CLIENTS = 3
        YEAR = 2000

        for i in range(10):
            lobbyist = LobbyistFactory.create()
            annum = LobbyistAnnumFactory.create(lobbyist=lobbyist, year=YEAR)
            for x in range(0, NUM_CLIENTS):
                CompensationFactory(annum=annum)

        # Here's a queryset to get the best paid `Lobbyist`s in a year
        qs = LobbyistAnnum.objects.filter(year=YEAR).annotate(
            income=Sum('compensation__amount_guess')).order_by('-income')
        for year in qs:
            # print year.lobbyist, year.income
            year
示例#16
0
    def test_make_stats_for_year_is_accurate(self):
        N = 10

        # associate N `Lobbyist`s with it through `LobbyistAnnum`
        for i in range(N):
            annum = LobbyistAnnumFactory.create(year=self.year)
            CompensationFactory.create(annum=annum, interest=self.interest,
                amount_guess=i, amount_high=i * 2, amount_low=0)
        with self.assertNumQueries(5):
            # 1 to get the stats
            # 1 to GET
            # 1 to INSERT
            # 2 for transaction management
            self.interest.make_stats_for_year(self.year)

        stat = self.interest.stats.all().get(year=self.year)
        self.assertEqual(stat.guess, N * (N - 1) / 2)  # math!
        self.assertEqual(stat.high, N * (N - 1))
        self.assertEqual(stat.low, 0)
示例#17
0
    def test_make_stats_for_year_is_accurate(self):
        N = 10

        # associate N `Lobbyist`s with it through `LobbyistAnnum`
        for i in range(N):
            annum = LobbyistAnnumFactory.create(year=self.year)
            CompensationFactory.create(annum=annum,
                                       interest=self.interest,
                                       amount_guess=i,
                                       amount_high=i * 2,
                                       amount_low=0)
        with self.assertNumQueries(5):
            # 1 to get the stats
            # 1 to GET
            # 1 to INSERT
            # 2 for transaction management
            self.interest.make_stats_for_year(self.year)

        stat = self.interest.stats.all().get(year=self.year)
        self.assertEqual(stat.guess, N * (N - 1) / 2)  # math!
        self.assertEqual(stat.high, N * (N - 1))
        self.assertEqual(stat.low, 0)
示例#18
0
    def test_make_stats_for_year_takes_aliases_into_account(self):
        """
        This is just like test_make_stats_for_year_is_accurate, except we
        spread the lobbyists to a pool of interests that are all really the
        same interest.
        """
        num_lobbyists = random.randint(7, 13)
        num_interests = random.randint(2, 3)

        # assert we started off with 1 `Interest` (self.interest)
        self.assertEqual(Interest.objects.count(), 1)
        for i in range(num_interests):
            InterestFactory(canonical=self.interest)
        # sanity check
        self.assertEqual(self.interest.aliases.count(), num_interests)

        # associate num_lobbyists `Lobbyist`s with it through `LobbyistAnnum`
        for i in range(num_lobbyists):
            year = LobbyistAnnumFactory.create(year=self.year)
            interest = Interest.objects.all().order_by('?')[0]
            CompensationFactory(annum=year,
                                interest=interest,
                                amount_guess=i,
                                amount_high=i * 2,
                                amount_low=0)
        with self.assertNumQueries(5):
            # 1 to get the stats
            # 1 to GET
            # 1 to INSERT
            # 2 for transaction management
            self.interest.make_stats_for_year(self.year)

        stat = self.interest.stats.all().get(year=self.year)
        self.assertEqual(stat.guess,
                         num_lobbyists * (num_lobbyists - 1) / 2)  # math!
        self.assertEqual(stat.high, num_lobbyists * (num_lobbyists - 1))
        self.assertEqual(stat.low, 0)
示例#19
0
    def test_interest_compensation_report_queryset(self):
        """Get a list of `Interest`s sorted by their bankroll of `Lobbyist`s."""
        YEAR = 2000

        for i in range(10):
            LobbyistFactory.create()
            InterestFactory.create()
            InterestFactory.create()

        for i in Interest.objects.all():
            lobbyist = Lobbyist.objects.all().order_by('?')[0]
            try:
                annum = LobbyistAnnum.objects.get(lobbyist=lobbyist, year=YEAR)
            except LobbyistAnnum.DoesNotExist:
                annum = LobbyistAnnumFactory.create(lobbyist=lobbyist, year=YEAR)
            CompensationFactory(annum=annum, interest=i)
            # denormalize interest stats
            i.make_stats_for_year(YEAR)

        # use `__exact`, django ORM attempts to evaluate __year as a date lookup
        for stat in InterestStats.objects.filter(year__exact=YEAR).order_by(
                '-guess'):
            # print stat
            stat
示例#20
0
 def test_make_stats_trivial_case_works(self):
     LobbyistAnnumFactory.create(year=self.year)
     # making stats for an interest with no compensation
     self.interest.make_stats()
     # assert interest did not have stats generated
     self.assertEqual(0, self.interest.stats.count())
示例#21
0
 def test_make_stats_trivial_case_works(self):
     LobbyistAnnumFactory.create(year=self.year)
     # making stats for an interest with no compensation
     self.interest.make_stats()
     # assert interest did not have stats generated
     self.assertEqual(0, self.interest.stats.count())