Пример #1
0
    def testKegStuff(self):
        """Test basic keg relations that should always work."""
        self.assertEqual(self.keg.full_volume_ml,
                         units.Quantity(2.0, units.UNITS.Liter).InMilliliters())
        self.assertEqual(self.keg.type.producer.name, "Moonshine Beers")

        self.assertEqual(0.0, self.keg.served_volume())
        self.assertEqual(2000, self.keg.remaining_volume_ml())
Пример #2
0
 def clean_volume(self):
     volume = self.cleaned_data['volume']
     if self.cleaned_data['units'] == 'oz':
         self.cleaned_data['volume_ml'] = float(
             units.Quantity(volume, units.UNITS.Ounce).InMilliliters())
     else:
         self.cleaned_data['volume_ml'] = volume
     return volume
Пример #3
0
 def clean_volume(self):
     volume = self.cleaned_data["volume"]
     if self.cleaned_data["units"] == "oz":
         self.cleaned_data["volume_ml"] = float(
             units.Quantity(volume, units.UNITS.Ounce).InMilliliters()
         )
     else:
         self.cleaned_data["volume_ml"] = volume
     return volume
Пример #4
0
def volume(text, fmt='pints'):
    try:
        vol = units.Quantity(float(text))
    except ValueError:
        return text
    if fmt == 'pints':
        res = vol.InPints()
    elif fmt == 'liters':
        res = vol.InLiters()
    elif fmt == 'ounces':
        res = vol.InOunces()
    elif fmt == 'gallons':
        res = vol.InUSGallons()
    elif fmt == 'twelveounces':
        res = vol.InTwelveOunceBeers()
    elif fmt == 'halfbarrels':
        res = vol.InHalfBarrelKegs()
    else:
        raise TemplateSyntaxError('Unknown volume format: %s' % fmt)
    return float(res)
Пример #5
0
def volume(text, fmt="pints"):
    try:
        vol = units.Quantity(float(text))
    except ValueError:
        return text
    if fmt == "pints":
        res = vol.InPints()
    elif fmt == "liters":
        res = vol.InLiters()
    elif fmt == "ounces":
        res = vol.InOunces()
    elif fmt == "gallons":
        res = vol.InUSGallons()
    elif fmt == "twelveounces":
        res = vol.InTwelveOunceBeers()
    elif fmt == "halfbarrels":
        res = vol.InHalfBarrelKegs()
    else:
        raise TemplateSyntaxError("Unknown volume format: %s" % fmt)
    return float(res)
Пример #6
0
def format_volume(volume_ml, chart_kwargs):
    metric_volumes = chart_kwargs.get("metric_volumes", False)
    if metric_volumes:
        return volume_ml / 1000.0, "L"
    else:
        return units.Quantity(volume_ml).InPints(), "pints"
Пример #7
0
    def testDrinkSessions(self):
        """ Checks for the DrinkingSession records. """
        u1 = self.user
        u2 = self.user2
        units.Quantity(1200)

        base_time = make_datetime(2009, 1, 1, 1, 0, 0)

        td_10m = datetime.timedelta(minutes=10)
        td_400m = datetime.timedelta(minutes=400)
        td_390m = td_400m - td_10m

        self.assertEqual(models.Drink.objects.all().count(), 0)
        self.assertEqual(models.DrinkingSession.objects.all().count(), 0)

        # u=1 t=0
        self.backend.record_drink(
            self.tap,
            ticks=1200,
            username=u1.username,
            pour_time=base_time,
        )
        # u=2 t=0
        self.backend.record_drink(
            self.tap,
            ticks=1200,
            username=u2.username,
            pour_time=base_time,
        )

        # u=1 t=10
        self.backend.record_drink(
            self.tap,
            ticks=1200,
            username=u1.username,
            pour_time=base_time + td_10m,
        )

        # u=1 t=400
        self.backend.record_drink(
            self.tap,
            ticks=1200,
            username=u1.username,
            pour_time=base_time + td_400m,
        )

        # u=2 t=490
        self.backend.record_drink(
            self.tap,
            ticks=1200,
            username=u2.username,
            pour_time=base_time + td_390m,
        )

        # u=2 t=400
        self.backend.record_drink(
            self.tap,
            ticks=1200,
            username=u2.username,
            pour_time=base_time + td_400m,
        )

        drinks_u1 = u1.drinks.all().order_by("time")

        s1, s2 = models.DrinkingSession.objects.all().order_by(
            "start_time")[:2]

        SESSION_DELTA = datetime.timedelta(
            minutes=kb_common.DRINK_SESSION_TIME_MINUTES)

        # session 1: should be 10 minutes long as created above
        self.assertEqual(s1.start_time, drinks_u1[0].time)
        self.assertEqual(s1.end_time,
                         drinks_u1[0].time + td_10m + SESSION_DELTA)
        self.assertEqual(s1.drinks.all().filter(user=u1).count(), 2)
        self.assertEqual(s1.drinks.all().filter(user=u2).count(), 1)

        # session 2: at time 200, 1 drink
        self.assertEqual(s2.start_time, base_time + td_390m)
        self.assertEqual(s2.end_time, base_time + td_400m + SESSION_DELTA)
        self.assertEqual(s2.drinks.all().filter(user=u1).count(), 1)
        self.assertEqual(s2.drinks.all().filter(user=u2).count(), 2)

        # Now check DrinkingSessions were created correctly; there should be
        # two groups capturing all 4 sessions.
        all_groups = models.DrinkingSession.objects.all().order_by(
            "start_time")
        self.assertEqual(len(all_groups), 2)

        self.assertEqual(all_groups[0].start_time, base_time)
        self.assertEqual(all_groups[0].end_time,
                         base_time + td_10m + SESSION_DELTA)

        self.assertEqual(all_groups[1].start_time, base_time + td_390m)
        self.assertEqual(all_groups[1].end_time,
                         base_time + td_400m + SESSION_DELTA)

        self.assertEqual("kb_tester2 and kb_tester", s2.summarize_drinkers())