def test_init_menus(self):
api_dict = {
"TestBar":
self.MockAPIPlan(
self.mockAPI,
["shit", "shit", "Stone", "Stone", "Founders"]).executor(),
}
good_menu1 = Menu("TestBar", [
MenuSection("1", "Title1",
[Beer("name Stone", "style", 8, "brewery")])
])
good_menu2 = Menu("TestBar", [
MenuSection("1", "Title1",
[Beer("name Founders", "style", 8, "brewery")])
])
mm = MenuManager(api_dict=api_dict)
self.assertEqual({}, mm.find_good_bars())
mm.update_menus()
self.assertEqual({}, mm.find_good_bars())
mm.update_menus()
self.assertEqual({"TestBar": good_menu1}, mm.find_good_bars())
mm.update_menus()
self.assertEqual({}, mm.find_good_bars())
mm.update_menus()
self.assertEqual({"TestBar": good_menu2}, mm.find_good_bars())
def test_MenuSectionEquals(self):
section_1 = MenuSection("123", "Beers")
section_2 = MenuSection("123", "Beers")
for i in range(3):
section_1.beers.append(Beer(str(i), str(i), i, str(i)))
section_2.beers.append(Beer(str(i), str(i), i, str(i)))
self.assertEqual(section_1, section_2, "Should be equal")
def test_IsNotWorthIt(self):
b1 = Beer("Breakfast stout", "Stout", 5.0, "No Brand")
b2 = Beer("Breakfast stout", "Stout", 8.0, "Some Brand")
b3 = Beer("Breakfast stout", "Stout", 6.0, "Founders")
self.assertEqual(b1.is_worth_it(), False)
self.assertEqual(b2.is_worth_it(), False)
self.assertEqual(b3.is_worth_it(), False)
def test_GoodBeers(self):
section = MenuSection("123", "Beers")
section.beers.append(Beer("One beer", "From", 18.0, "There"))
section.beers.append(Beer("Breakfast Stout", "From", 9.0, "Founders"))
good_beers = section.good_beers()
self.assertEqual(len(good_beers), 1)
self.assertEqual(good_beers[0],
Beer("Breakfast Stout", "From", 9.0, "Founders"))
def test_FromDict(self):
b = Beer("Breakfast stout", "Stout", 8.0, "Founders")
b_dict = {
"name": "Breakfast stout",
"style": "Stout",
"abv": 8.0,
"brewery": "Founders"
}
self.assertEqual(b, Beer().from_dict(b_dict))
def test_BeerUnEquals(self):
b1 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
b2 = Beer("Breakfast Stout", "Stout", 8.0, "Founders")
b3 = Beer("Breakfast stout", "IPA", 8.0, "Founders")
b4 = Beer("Breakfast stout", "Stout", 7.0, "Founders")
b5 = Beer("Breakfast stout", "Stout", 8.0, "Stone")
self.assertNotEqual(b1, b2)
self.assertNotEqual(b1, b3)
self.assertNotEqual(b1, b4)
self.assertNotEqual(b1, b5)
def test_Constructor(self):
section_1 = MenuSection("123", "Beers")
section_2 = MenuSection("124", "More beers",
[Beer("B", "EE", 1.0, "R")])
self.assertEqual(section_1.section_id, "123")
self.assertEqual(section_1.title, "Beers")
self.assertEqual(len(section_1.beers), 0)
self.assertEqual(section_2.section_id, "124")
self.assertEqual(section_2.title, "More beers")
self.assertEqual(len(section_2.beers), 1)
self.assertEqual(section_2.beers[0], Beer("B", "EE", 1.0, "R"))
def test_MenuSectionUnequals(self):
section_1 = MenuSection("123", "Beers")
section_2 = MenuSection("124", "Beers")
section_3 = MenuSection("123", "beers")
section_4 = MenuSection("124", "beers")
for i in range(3):
section_1.beers.append(Beer(str(i), str(i), i, str(i)))
section_2.beers.append(Beer(str(i), str(i), i, str(i)))
section_3.beers.append(Beer(str(i), str(i), i, str(i)))
section_1.beers.append(Beer("different", "section", 5.0, "brew"))
self.assertNotEqual(section_1, section_2, "Should not be equal")
self.assertNotEqual(section_1, section_3, "Should not be equal")
self.assertNotEqual(section_1, section_4, "Should not be equal")
class TestTelegramBotUtil(unittest.TestCase):
beer_1 = Beer("Breakfast Stout", "Stout", "8.6", "Founders")
beer_2 = Beer("Stone IPA", "IPA", "5.6", "Stone")
section_1 = MenuSection("111", "On Tap (2 bier)", [beer_1, beer_2])
empty_section = MenuSection("222", "Empty", [])
menu_1 = Menu("TAP", [section_1, empty_section])
menu_2 = Menu("FooBar", [section_1, empty_section])
beer_1_text = "Breakfast Stout\n" \
"8.6% ABV\n" \
"Stout\n" \
"Founders\n"
beer_2_text = "Stone IPA\n" \
"5.6% ABV\n" \
"IPA\n" \
"Stone\n"
section_1_text = "_On Tap_ (2 Beers)\n" \
" ---Beer 1---\n" \
"{}" \
" ---Beer 2---\n" \
"{}".format(beer_1_text, beer_2_text)
menu_1_text = "*TAP*\n" \
"{}".format(section_1_text)
menu_2_text = "*FooBar*\n" \
"{}".format(section_1_text)
def test_beer_in_markdown(self):
actual_text = util.beer_to_markdown(self.beer_1)
self.assertEqual(actual_text, self.beer_1_text)
def test_menusection_in_markdown(self):
actual_text = util.section_to_markdown(self.section_1)
self.assertEqual(actual_text, self.section_1_text)
def test_menu_in_markdown(self):
actual_text = util.menu_to_markdown(self.menu_1)
self.assertEqual(actual_text, self.menu_1_text)
def test_multiple_menus_in_markdown(self):
actual_text = util.multiple_menus_to_markdown({
"TAP": self.menu_1,
"FooBar": self.menu_2
})
self.assertEqual(actual_text,
self.menu_1_text + "\n" + self.menu_2_text)
def request_menu():
logging.info("Retrieving TAP Craft Beer Menu")
try:
# Get menu location
headers = {
'Accept-Language':
'en-GB,en-US;q=0.9,en;q=0.8',
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36',
'Accept':
'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
}
response1 = requests.get('http://menu.tapthat.com.sg/',
headers=headers)
# print(response1.content)
response_string = response1.content.decode('utf-8')
groups = re.search(
'PreloadEmbedMenu\("menu-container",([0-9]+),([0-9]+)\)',
response_string)
# print(groups[1], groups[2])
# Retrieve menu
response2 = requests.get(
'https://business.untappd.com/locations/{}/themes/{}/js'.format(
groups.group(1), groups.group(2)),
headers=headers)
# print(response.content)
menu_html = str(response2.content)
menu_html = ' '.join(
menu_html.replace('\\n', '').replace('\\', '').split())
menu_html = html.unescape(menu_html)
# print(menu_html)
beer_regex = re.compile(
'<!-- Beer Name \+ Style -->.+?<\/span>(.+?)\s<\/a>.+?item-title-color">(.+?)<\/span>.+?"abv">(.+?)%\sABV',
re.DOTALL)
beer_groups = beer_regex.finditer(menu_html)
beers = []
for beer_group in beer_groups:
beers.append(
Beer(beer_group.group(1), beer_group.group(2),
float(beer_group.group(3))))
logging.info("Retrieved {} beers from Tap Craft Beer.".format(
len(beers)))
return beers
except:
logging.error("Error getting Tap Craft Beer menu: {}".format(
sys.exc_info()[0]))
traceback.print_exc()
return []
def test_ToDict(self):
b = Beer("Breakfast stout", "Stout", 8.0, "Founders")
b_dict = {
"name": "Breakfast stout",
"style": "Stout",
"abv": 8.0,
"brewery": "Founders"
}
self.assertEqual(b.to_dict(), b_dict)
def parse_beer_data(beers_data):
beer_dicts = []
variables = [x for x in dir(Beer) if not (x.startswith('_'))]
for b in beers_data:
# print json.dumps(b)
bb = Beer(b)
beer_dict = dict((name, getattr(bb, name)) for name in variables)
beer_dicts.append(beer_dict)
return beer_dicts
def test_FromDict(self):
section = MenuSection("123", "Beers")
section.beers.append(Beer("One beer", "From", 18.0, "There"))
section.beers.append(Beer("Two beer", "From", 9.0, "Here"))
section_dict = {
"section_id":
"123",
"title":
"Beers",
"beers": [{
"name": "One beer",
"style": "From",
"abv": 18.0,
"brewery": "There"
}, {
"name": "Two beer",
"style": "From",
"abv": 9.0,
"brewery": "Here"
}]
}
self.assertEqual(section, MenuSection().from_dict(section_dict))
def post(self):
json_string = self.request.body
dict_object = json.loads(json_string)
beer_name = dict_object['beerName']
beer_style = dict_object['beerStyle']
beer_price = float(dict_object['beerPrice'])
beer_abv = float(dict_object['beerAbv'])
beer_ibus = int(dict_object['beerIbus'])
beer_srm = int(dict_object['beerSrm'])
beer_on_tap = bool(dict_object['beerOnTap'])
beer_tap_list_image = dict_object['beerTapListImage']
beer_description = dict_object['beerDescription']
beer_description_image = dict_object['beerDescriptionImage']
same_name = Beer.query(Beer.name == beer_name).fetch()
if not same_name:
#NDB storing
beer = Beer(name=beer_name,
style=beer_style,
tap_list_image=beer_tap_list_image,
description=beer_description,
description_image=beer_description_image,
price=beer_price,
abv=beer_abv,
ibus=beer_ibus,
srm=beer_srm,
on_tap=beer_on_tap)
beer_key = beer.put()
beer_id = str(beer_key.id())
res = {
"msg": "Beer successfully added",
"success": True,
"beer_id": beer_id
}
self.response.out.write(json.dumps(res))
else:
res = {
"msg":
"That beer already exists in the inventory or something went wrong. Please try again.",
"success": False
}
self.response.out.write(json.dumps(res))
def build_menu_from_html(self, page):
tree = html.document_fromstring(page)
m = Menu(self.bar_name)
# Get all menu sections
sections = tree.find_class("menu-section")
for section in sections:
# Get section details
section_id_string = section.get("id")
section_id = re.search("section_(.+?)$",
section_id_string).group(1)
title = self.sanitize_markdown_characters(
section.find_class("menu-section-header")[0].text_content())
beer_list = section.find_class("menu-section-list")
beers = beer_list[0].getchildren()
# If not all beers are loaded
if len(section.find_class("show-more-section")) > 0:
logging.debug(
"Loading more beers for {}.".format(section_id_string))
beers += self.load_section(section_id)
# There are beers in this section
if len(beers) > 0:
ms = MenuSection(section_id, title)
for beer in beers:
details = beer.find_class("beer-details")[0]
h5, h6 = details.getchildren()
name, style = h5.getchildren()
abv = h6.getchildren()[0]
brewery = h6.getchildren()[0].getchildren()[0]
ms.beers.append(
Beer(
self.sanitize_markdown_characters(
name.text_content()),
self.sanitize_markdown_characters(
style.text_content()),
self.sanitize_markdown_characters(
self.get_abv_from_span(abv.text_content())),
self.sanitize_markdown_characters(
brewery.text_content())))
m.sections.append(ms)
return m
def make_beer(self, data, **kwargs):
beer_args = {'id': str(uuid1()), **data}
return Beer(**beer_args)
def test_repr(self):
b = Beer("Breakfast stout", "Stout", 8.0, "Founders")
self.assertEqual(str(b), "Beer(name=Breakfast stout, style=Stout, abv=8.0, brewery=Founders)")
def test_BeerEquals(self):
b1 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
b2 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
self.assertEqual(b1, b2)
def mockAPI(self, beername=""):
return Menu("TestBar", [
MenuSection("1", "Title1",
[Beer("name " + beername, "style", 8, "brewery")])
])
def test_IsWorthIt(self):
b1 = Beer("Breakfast stout", "Stout", 8.0, "Founders")
b2 = Beer("Founders Breakfast stout", "Stout", 8.0, "None")
self.assertEqual(b1.is_worth_it(), True)
self.assertEqual(b2.is_worth_it(), True)
def make_beer(self, data, **kwargs):
return Beer(**data)
def get_model(self, param):
return Beer(param)
