def test_import_taplist_io_data(self):
"""Test parsing the JSON data"""
timestamp = now()
responses.add(
responses.GET,
TaplistDotIOParser.URL.format(
self.venue_cfg.taplist_io_display_id, ),
json=self.json_data,
status=200,
)
self.assertFalse(Tap.objects.exists())
self.assertEqual(Venue.objects.count(), 1)
self.assertFalse(Beer.objects.exists())
self.assertFalse(Manufacturer.objects.exists())
mfg = ManufacturerFactory(name="InnerSpace", )
ManufacturerAlternateName.objects.bulk_create(
ManufacturerAlternateName(
manufacturer=mfg,
name=name,
) for name in [
"Isb",
"InnerSpace Brewing Company",
"InnerSpace Brewing co",
])
for dummy in range(2):
# running twice to make sure we're not double-creating
args = []
opts = {}
call_command("parsetaplistio", *args, **opts)
self.assertEqual(Beer.objects.count(), 10,
list(Beer.objects.all()))
self.assertEqual(Manufacturer.objects.count(), 1)
self.assertEqual(Tap.objects.count(), 13)
taps = (Tap.objects.filter(
venue=self.venue,
tap_number__in=[1, 2, 10],
).select_related(
"beer__style",
"beer__manufacturer",
).order_by("tap_number"))
tap = taps[0]
self.assertEqual(tap.beer.name, "SkyFarmer Farmhouse Ale")
self.assertEqual(tap.beer.manufacturer.name, mfg.name)
self.assertEqual(tap.beer.style.name, "Farmhouse Ale")
self.assertEqual(tap.time_updated, self.timestamp)
# location nulled out in test data
tap = taps[1]
self.assertIsNone(tap.beer_id)
self.assertEqual(tap.time_updated, self.timestamp)
tap = taps[2]
self.assertEqual(tap.beer.manufacturer.name, mfg.name)
self.assertEqual(tap.beer.name, "Denver Destroyer")
# NOTE: Yes, really.
self.assertEqual(tap.beer.style.name, "An elusive IPA")
self.assertEqual(tap.time_updated, self.timestamp)
self.venue.refresh_from_db()
self.assertIsNotNone(self.venue.tap_list_last_check_time)
self.assertGreater(self.venue.tap_list_last_check_time, timestamp)
self.assertIsNotNone(self.venue.tap_list_last_update_time)
def setUpTestData(cls):
super().setUpTestData()
cls.manufacturer = ManufacturerFactory()
cls.venue = VenueFactory(
tap_list_provider=ArryvedMenuParser.provider_name)
cls.venue_cfg = VenueAPIConfiguration.objects.create(
venue=cls.venue,
arryved_location_id="abc123",
arryved_menu_id="def456",
arryved_manufacturer_name=cls.manufacturer.name,
arryved_serving_sizes=[
"TAS",
"32O",
"64O",
"13O",
"PIN",
],
)
with open(
os.path.join(
os.path.dirname(BASE_DIR),
"tap_list_providers",
"example_data",
"arryved_menu.json",
),
"rb",
) as json_file:
cls.json_data = json.loads(json_file.read())
def setUpTestData(cls):
super().setUpTestData()
cls.venue = VenueFactory(
tap_list_provider=BeerMenusParser.provider_name)
cls.venue_cfg = VenueAPIConfiguration.objects.create(
venue=cls.venue,
beermenus_slug=BAD_DADDYS_SLUG,
beermenus_categories=['on_tap', 'featured'],
)
cls.locations = []
cls.main_menu = ''
cls.read_more = ''
for name in os.listdir(PATH):
if name.startswith(BAD_DADDYS_SLUG):
url = (f'https://www.beermenus.com/places/'
f'{name.replace("__", "?").split(".")[0]}')
with open(os.path.join(PATH, name)) as infile:
html = infile.read()
if '?' in url:
cls.read_more = html
else:
cls.base_url = url
cls.main_menu = html
else:
url = ('https://www.beermenus.com/beers/'
f'{name.split(".")[0]}')
with open(os.path.join(PATH, name)) as infile:
cls.locations.append((url, name, infile.read()))
rocket = ManufacturerFactory(name='Rocket Republic Brewing Company')
ManufacturerAlternateName.objects.create(
name='Rocket Republic',
manufacturer=rocket,
)
def test_guess_manufacturer_back_forty(self):
mfg = ManufacturerFactory(name="Back Forty")
ManufacturerAlternateName.objects.bulk_create(
ManufacturerAlternateName(name=name, manufacturer=mfg)
for name in ["Back Forty", "Back Forty Beer Co"])
parser = StemAndSteinParser()
guessed = parser.guess_beer("Back Forty Truck Stop Honey Brown")
self.assertEqual(guessed.manufacturer, mfg)
def test_twitter_handle(self):
mfg = ManufacturerFactory(twitter_handle="abc123")
provider = BaseTapListProvider()
looked_up = provider.get_manufacturer(
name=mfg.name,
twitter_handle="https://twitter.com/foobar",
)
self.assertEqual(looked_up, mfg)
self.assertEqual(looked_up.twitter_handle, "foobar")
def test_mfg_duplicate_alt_name(self):
mfg = ManufacturerFactory(name='Founders')
ManufacturerAlternateName.objects.create(name=mfg.name,
manufacturer=mfg)
ManufacturerAlternateName.objects.create(
name='Founders Brewing Co.',
manufacturer=mfg,
)
provider = BaseTapListProvider()
looked_up = provider.get_manufacturer(name=mfg.name)
self.assertEqual(looked_up, mfg)
def test_guess_manufacturer_goat_island(self):
mfg_names = [
'Horny Goat Brewing Company', 'Goat Island Brewing', 'Goat Island',
]
manufacturers = [
ManufacturerFactory.build(name=name) for name in mfg_names
]
Manufacturer.objects.bulk_create(manufacturers)
parser = StemAndSteinParser()
guessed = parser.guess_manufacturer('Goat Island Sipsey River Red Ale')
self.assertEqual(guessed.name, 'Goat Island', guessed)
self.assertIn(guessed, manufacturers)
def test_guess_manufacturer_good_people(self):
mfg_names = [
'Goodwood', 'Good People Brewing Company', 'Good People',
'Good People Brewing Co.',
]
manufacturers = [
ManufacturerFactory.build(name=name) for name in mfg_names
]
Manufacturer.objects.bulk_create(manufacturers)
parser = StemAndSteinParser()
guessed = parser.guess_manufacturer('Good People IPA')
self.assertEqual(guessed.name, 'Good People', guessed)
self.assertIn(guessed, manufacturers)
def test_guess_manufacturer_stone(self):
mfg_names = [
'New Realm Brewing Company / Stone', 'Stone Brewing ', 'Stone',
'Stone Brewing Co.', 'Stone Brewing',
]
manufacturers = [
ManufacturerFactory.build(name=name) for name in mfg_names
]
Manufacturer.objects.bulk_create(manufacturers)
parser = StemAndSteinParser()
guessed = parser.guess_manufacturer('Stone Enjoy By 04.20.19 IPA')
self.assertEqual(guessed.name, 'Stone', guessed)
self.assertIn(guessed, manufacturers)
def test_beers(self):
mfg = ManufacturerFactory()
beers = Beer.objects.bulk_create(
BeerFactory.build(manufacturer=mfg) for dummy in range(10))
taps = Tap.objects.bulk_create(
Tap(
beer=beer,
tap_number=index + 1,
venue=self.venue,
) for index, beer in enumerate(beers))
response = self.client.get(f"{self.url}beers/")
self.assertEqual(len(taps), len(beers))
self.assertEqual(Beer.objects.count(), len(beers))
self.assertEqual(response.status_code, 200, response.data)
self.assertEqual(len(response.data["results"]), len(beers))
def test_manufacturer_lookup(self):
mfg = ManufacturerFactory(name='Stone')
provider = BaseTapListProvider()
for name in [
'Stone Brewing Company',
'Stone Brewing',
'Stone',
'Stone Beer Co.',
]:
looked_up = provider.get_manufacturer(name)
self.assertEqual(
mfg,
looked_up,
f'{looked_up.name} does not match {name}',
)
self.assertEqual(Manufacturer.objects.count(), 1, name)
def test_invalid_gas(self):
self.client.force_login(self.normal_user)
VenueTapManager.objects.create(venue=self.venue, user=self.normal_user)
form_data = {
"beer": BeerFactory(manufacturer=ManufacturerFactory()).id,
"estimated_percent_remaining": 90,
"gas_type": "xenon",
}
with self.assertNumQueries(12):
response = self.client.post(self.edit_url, data=form_data)
self.assertEqual(response.status_code, 400)
self.assertTemplateUsed(response, "taps/tap_form.html")
self.assertIn(
"Select a valid choice. xenon is not one of the available choices.",
response.content.decode("utf-8"),
)
def test_manufacturer_lookup(self):
mfg = ManufacturerFactory(name="Stone")
provider = BaseTapListProvider()
for name in [
"Stone Brewing Company",
"Stone Brewing",
"Stone",
"Stone Beer Co.",
]:
looked_up = provider.get_manufacturer(name)
self.assertEqual(
mfg,
looked_up,
f"{looked_up.name} does not match {name}",
)
self.assertEqual(Manufacturer.objects.count(), 1, name)
def test_invalid_percent_remaining(self):
self.client.force_login(self.normal_user)
VenueTapManager.objects.create(venue=self.venue, user=self.normal_user)
self.assertFalse(Beer.objects.exists())
form_data = {
"beer": BeerFactory(manufacturer=ManufacturerFactory()).id,
"estimated_percent_remaining": 101,
"gas_type": "co2",
}
with self.assertNumQueries(12):
response = self.client.post(self.edit_url, data=form_data)
self.assertEqual(response.status_code, 400)
self.assertTemplateUsed(response, "taps/tap_form.html")
self.assertIn(
"A keg cannot be more than 100% full.",
response.content.decode("utf-8"),
)
def setUpTestData(cls):
super().setUpTestData()
cls.venue = VenueFactory()
cls.normal_user = UserFactory()
cls.styles = Style.objects.bulk_create(StyleFactory.build_batch(50))
cls.manufacturer = ManufacturerFactory()
cls.beers = Beer.objects.bulk_create(
BeerFactory.build(style=style, manufacturer=cls.manufacturer)
for style in cls.styles)
cls.taps = Tap.objects.bulk_create(
TapFactory.build(
beer=beer,
venue=cls.venue,
tap_number=index,
) for index, beer in enumerate(cls.beers))
VenueTapManager.objects.create(
user=cls.normal_user,
venue=cls.venue,
)
def test_superuser_valid_form_new_tap(self):
self.client.force_login(UserFactory(is_superuser=True))
form_data = {
"beer": BeerFactory(manufacturer=ManufacturerFactory()).id,
"estimated_percent_remaining": 90,
"gas_type": "co2",
}
with self.assertNumQueries(10):
response = self.client.post(self.create_url, data=form_data)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response["Location"],
reverse("venue_table", args=[self.venue.id]),
)
tap = Tap.objects.exclude(id=self.existing_tap.id).get()
self.assertEqual(tap.beer_id, form_data["beer"])
self.assertEqual(tap.estimated_percent_remaining, 90)
self.assertEqual(tap.gas_type, "co2")
self.assertEqual(Tap.objects.count(), 2)
def test_valid_form_existing_tap(self):
self.client.force_login(self.normal_user)
VenueTapManager.objects.create(venue=self.venue, user=self.normal_user)
form_data = {
"beer": BeerFactory(manufacturer=ManufacturerFactory()).id,
"estimated_percent_remaining": 90,
"gas_type": "co2",
}
with self.assertNumQueries(12):
response = self.client.post(self.edit_url, data=form_data)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response["Location"],
reverse("venue_table", args=[self.venue.id]),
)
self.existing_tap.refresh_from_db()
self.assertEqual(self.existing_tap.beer_id, form_data["beer"])
self.assertEqual(self.existing_tap.estimated_percent_remaining, 90)
self.assertEqual(self.existing_tap.gas_type, "co2")
self.assertEqual(Tap.objects.count(), 1)
def setUp(self):
manufacturer = ManufacturerFactory()
venue = VenueFactory()
style = StyleFactory()
self.beers = Beer.objects.bulk_create(
BeerFactory.build(
manufacturer=manufacturer,
style=style,
) for _ in range(20))
self.prices = BeerPrice.objects.bulk_create(
BeerPrice(
# pint
serving_size_id=1,
price=index * 2.1,
beer=beer,
venue=venue,
) for index, beer in enumerate(self.beers))
self.taps = Tap.objects.bulk_create(
# only for half of them
TapFactory.build(beer=beer, venue=venue)
for beer in self.beers[:10])
def test_valid_form_remove_beer(self):
self.client.force_login(self.normal_user)
VenueTapManager.objects.create(venue=self.venue, user=self.normal_user)
self.existing_tap.beer = BeerFactory(
manufacturer=ManufacturerFactory())
self.existing_tap.save()
form_data = {
"beer": "",
"estimated_percent_remaining": 0.9,
"gas_type": "co2",
}
with self.assertNumQueries(10):
response = self.client.post(self.edit_url, data=form_data)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response["Location"],
reverse("venue_table", args=[self.venue.id]),
)
tap = Tap.objects.get()
self.assertIsNone(tap.beer)
self.assertIsNone(tap.estimated_percent_remaining)
self.assertEqual(tap.gas_type, "")
def test_multi_beer_more_to_come(self, mock_retry, mock_api):
mfg = ManufacturerFactory()
beers = Beer.objects.bulk_create(
BeerFactory.build(manufacturer=mfg, style=None)
for dummy in range(20))
Tap.objects.bulk_create(
TapFactory.build(venue=self.venue, beer=beer) for beer in beers)
with self.settings_context_manager():
tweet_about_beers([i.id for i in beers]) # pylint: disable=no-value-for-parameter
beers = beers[:10]
mock_retry.assert_not_called()
mock_api.assert_called_once_with(
consumer_key=self.consumer_key,
consumer_secret=self.consumer_secret,
access_token_key=self.api_key,
access_token_secret=self.api_secret,
)
mock_api.return_value.PostUpdates.assert_called_once()
mock_api.return_value.PostUpdate.assert_not_called()
call_args = mock_api.return_value.PostUpdates.call_args
self.assertEqual(call_args[1], {"continuation": "…", "threaded": True})
self.assertEqual(len(call_args[0]), 1)
tweet = call_args[0][0]
self.assertIn(
MULTI_BEER_OUTER.format(len(beers), "(10 still to come!)").strip(),
tweet,
)
lines = tweet.splitlines()
self.assertEqual(len(lines), 1 + len(beers))
for beer, line in zip(beers, lines[1:]):
self.assertIn(
MULTI_BEER_INNER.format(
beer.name,
"@" + beer.manufacturer.twitter_handle,
"unknown",
self.venue.name,
),
line,
)
def setUpTestData(cls):
super().setUpTestData()
cls.manufacturer = ManufacturerFactory(name="Cahaba")
cls.venue = VenueFactory(
tap_list_provider=ArryvedPOSParser.provider_name)
cls.venue_cfg = VenueAPIConfiguration.objects.create(
venue=cls.venue,
arryved_location_id="abc123",
arryved_pos_menu_names=["Growlers and Crowlers"],
arryved_manufacturer_name=cls.manufacturer.name,
arryved_serving_sizes=["32O", "64o"],
)
with open(
os.path.join(
os.path.dirname(BASE_DIR),
"tap_list_providers",
"example_data",
"cahaba.json",
),
"rb",
) as json_file:
cls.json_data = json.loads(json_file.read())
def test_multi_beer(self, mock_retry, mock_api):
mfg = ManufacturerFactory()
beers = Beer.objects.bulk_create(
BeerFactory.build(manufacturer=mfg, style=None) for dummy in range(10)
)
Tap.objects.bulk_create(
TapFactory.build(venue=self.venue, beer=beer)
for beer in beers
)
with self.settings_context_manager():
tweet_about_beers([i.id for i in beers])
mock_retry.assert_not_called()
mock_api.assert_called_once_with(
consumer_key=self.consumer_key,
consumer_secret=self.consumer_secret,
access_token_key=self.api_key,
access_token_secret=self.api_secret,
)
mock_api.return_value.PostUpdates.assert_called_once()
mock_api.return_value.PostUpdate.assert_not_called()
call_args = mock_api.return_value.PostUpdates.call_args
self.assertEqual(call_args[1], {'continuation': '…', 'threaded': True})
self.assertEqual(len(call_args[0]), 1)
tweet = call_args[0][0]
self.assertIn(
MULTI_BEER_OUTER.format(len(beers), '').strip(),
tweet,
)
lines = tweet.splitlines()
self.assertEqual(len(lines), 1 + len(beers))
for beer, line in zip(beers, lines[1:]):
self.assertIn(MULTI_BEER_INNER.format(
beer.name,
'@' + beer.manufacturer.twitter_handle,
'unknown',
self.venue.name,
), line)
def setUpTestData(cls) -> None:
cls.normal_user = UserFactory()
cls.venue = VenueFactory()
cls.existing_tap = TapFactory(venue=cls.venue)
cls.manufacturers = Manufacturer.objects.bulk_create(
ManufacturerFactory.build_batch(2))
def test_import_stemandstein_data(self):
"""Test parsing the JSON data"""
for pk, html_data in self.html_data.items():
if pk == "root":
url = "https://thestemandstein.com/"
else:
url = f"https://thestemandstein.com/Home/BeerDetails/{pk}"
responses.add(responses.GET, url, body=html_data, status=200)
self.assertFalse(Tap.objects.exists())
self.assertEqual(Venue.objects.count(), 1)
self.assertFalse(Beer.objects.exists())
self.assertFalse(Manufacturer.objects.exists())
deleted_tap = Tap.objects.create(
venue=self.venue,
tap_number=3000,
)
mfg = ManufacturerFactory(name="Founders")
beer = BeerFactory(name="Dirty Bastard", manufacturer=mfg)
other = Style.objects.create(name="other")
# Create a fake shorter style name that the search for fruit ale should
# ignore
StyleAlternateName.objects.create(name="t Ale", style=other)
style = Style.objects.create(name="Fruit Beer")
StyleAlternateName.objects.create(name="Fruit Ale", style=style)
for dummy in range(2):
# running twice to make sure we're not double-creating
args = []
opts = {}
call_command("parsestemandstein", *args, **opts)
self.assertEqual(Beer.objects.count(), 17)
# Bell's and Founders have two each
self.assertEqual(Manufacturer.objects.count(), 15)
self.assertEqual(Tap.objects.count(), 17)
taps = (Tap.objects.filter(
venue=self.venue,
tap_number__in=[1, 3, 9, 17],
).select_related(
"beer__style",
"beer__manufacturer",
).order_by("tap_number"))
tap = taps[0]
self.assertTrue(
tap.beer.name.endswith("Space Blood Orange Cider"),
tap.beer.name,
)
self.assertEqual(tap.beer.manufacturer.location, "Sebastopol, CA")
self.assertEqual(tap.beer.abv, Decimal("6.9"))
self.assertEqual(tap.beer.stem_and_stein_pk, 967)
prices = list(tap.beer.prices.all())
self.assertEqual(len(prices), 1)
price = prices[0]
self.assertEqual(price.price, 5)
self.assertEqual(price.serving_size.volume_oz, 16)
tap = taps[3]
# this one ends with an asterisk. Make sure it's stripped.
self.assertTrue(
tap.beer.name.endswith("Karmeliet"),
tap.beer.name,
)
self.assertEqual(tap.beer.manufacturer.location, "Belgium")
prices = list(tap.beer.prices.all())
self.assertEqual(len(prices), 1)
price = prices[0]
self.assertEqual(price.price, 8)
self.assertEqual(price.serving_size.volume_oz, 10)
self.assertFalse(Tap.objects.filter(id=deleted_tap.id).exists())
# make sure style stripping works
tap = taps[2]
self.assertEqual(tap.beer.style.name, "Scotch Ale")
self.assertEqual(tap.beer.name, "Dirty Bastard")
self.assertEqual(tap.beer.id, beer.id)
self.assertEqual(tap.beer.manufacturer_id, mfg.id)
tap = taps[1]
# style is set to Fruit Ale but the beer name is preserved
self.assertEqual(tap.beer.style_id, style.id)
self.assertTrue(tap.beer.name.endswith("Fruit Ale"))
