def run_homework():
cookie = Product(name="Ciastko", category_name="Jedzenie", unit_price=4)
# other_cookie = Product(name="Inne ciastko", category_name="Jedzenie", unit_price=4)
juice = Product(name="Sok", category_name="Napoje", unit_price=3)
first_order_elements = [
OrderElement(product=cookie, quantity=3),
# OrderElement(product=other_cookie, quantity=3),
OrderElement(product=juice, quantity=4),
]
# first_order_elements.append(OrderElement(product=juice, quantity=4))
# first_order_elements[0].quantity = 10
second_order_elements = [
OrderElement(product=juice, quantity=4),
OrderElement(product=cookie, quantity=3),
]
first_order = Order(client_first_name="Kuba",
client_last_name="Kowalski",
order_elements=first_order_elements)
second_order = Order(client_first_name="Kuba",
client_last_name="Kowalski",
order_elements=second_order_elements)
# second_order.client_last_name = "Lewandowski"
if first_order == second_order:
print("Te zamówienia są takie same!")
else:
print("Te zamówienia są różne!")
def test_getPriceWithCurrency(self):
# Given
sut = Product(basePrice=1542.3, currency="€")
# When
result = sut.getPriceWithCurrency()
# Then
self.assertEqual("1542.30 €", result)
# Given
sut = Product(basePrice=20, currency="$")
# When
result = sut.getPriceWithCurrency()
# Then
self.assertEqual("20.00 $", result)
# Given
sut = Product(basePrice=20, currency=None)
# When
result = sut.getPriceWithCurrency()
# Then
self.assertEqual("20.00 [UNKNOWN CURRENCY]", result)
# Given
sut = Product(basePrice=None, currency="$")
# When
result = sut.getPriceWithCurrency()
# Then
self.assertEqual("unknown", result)
def run_homework():
product_one = Product(name="Cookies", category_name="Food", unit_price=3.5)
product_two = Product(name="Cheese", category_name="Food", unit_price=3.5)
product_three = Product(name="Cookies",
category_name="Food",
unit_price=3.5)
print(f"Products 1 and 2 are equal? {product_one == product_two}")
print(f"Products 1 and 3 are equal? {product_one == product_three}")
print(f"Products 2 and 3 are equal? {product_two == product_three}")
order_element_1 = OrderElement(product_one, 3)
order_element_2 = OrderElement(product_one, 3)
order_element_3 = OrderElement(product_two, 4)
print(
f"Order elements 1 and 2 are equal? {order_element_1 == order_element_2}"
)
print(
f"Order elements 1 and 3 are equal? {order_element_1 == order_element_3}"
)
print(
f"Order elements 2 and 3 are equal? {order_element_2 == order_element_3}"
)
order_1 = Order(client_first_name="Maciej",
client_last_name="Sobieszuk",
order_elements=[order_element_1, order_element_2])
order_2 = Order(client_first_name="Maciej",
client_last_name="Sobieszuk",
order_elements=[order_element_2, order_element_1])
order_3 = Order(client_first_name="Maciej",
client_last_name="Xyz",
order_elements=[order_element_1, order_element_2])
print(f"Orders 1 and 2 are equal? {order_1 == order_2}")
print(f"Orders 1 and 3 are equal? {order_1 == order_3}")
print(f"Orders 2 and 3 are equal? {order_2 == order_3}")
def run_homework():
cookie = Product(name="Ciastko", category_name="Jedzenie", unit_price=4)
tomato = Product(name="Pomidor", category_name="Owoce i warzywa", unit_price=3)
something = Product(name="Coś", category_name="Nieznana kategoria", unit_price=50)
ten_cookies = OrderElement(cookie, quantity=10)
five_tomatoes = OrderElement(tomato, quantity=5)
single_something = OrderElement(something, quantity=1)
cookies_tax = TaxCalculator.tax_for_order_element(ten_cookies)
tomatoes_tax = TaxCalculator.tax_for_order_element(five_tomatoes)
something_tax = TaxCalculator.tax_for_order_element(single_something)
print(f"Cena ciastek: {ten_cookies.calculate_price()} + {cookies_tax:.2f}")
print(f"Cena pomidorów: {five_tomatoes.calculate_price()} + {tomatoes_tax:.2f}")
print(f"Cena czegoś: {single_something.calculate_price()} + {something_tax:.2f}")
def _decodeProducts(cls, productItems: list) -> List[Product]:
decodedProducts: List[Product] = list()
for productItem in productItems:
product = Product(**productItem)
product.sizes = cls._decodeSizes(product.sizes)
decodedProducts.append(product)
return decodedProducts
def test_product_eq():
parameters = [
("Banan", "Owoc", 2, "Ananas", "Owoc", 4, False),
("Stek", "Mięso", 50, "Yaris", "Auto", 10000, False),
("Yaris", "Auto", 10000, "Yaris", "Auto", 10000, True),
("Banan", "Owoc", 2, "Ananas", "Owoc", 4, True)
]
for params in parameters:
name, category_name, unit_price, other_name, other_category_name, other_unit_price, expected_result = params
result = Product(name, category_name, unit_price, Product.identifier) == \
Product(other_name, other_category_name, other_unit_price, Product.identifier)
if result == expected_result:
print("Super!")
else:
print(f"Błąd! Dla danych {params} wynik powinen wynosić {expected_result} a wynosi {result}.")
def load_orders(client_first_name, client_last_name, file_name="orders.json"):
try:
with open(file_name, "r") as orders_file:
orders_by_clients_data = json.load(orders_file).get("orders", {})
except FileNotFoundError:
orders_by_clients_data = {}
client_id = f"{client_first_name}-{client_last_name}"
if client_id not in orders_by_clients_data:
return []
orders = orders_by_clients_data[client_id]
return [
Order(
client_first_name=order["client_first_name"],
client_last_name=order["client_last_name"],
order_elements=[
OrderElement(
quantity=order_element["quantity"],
product=Product(
name=order_element["product"]["name"],
category=ProductCategory[order_element["product"]
["category"]],
unit_price=order_element["product"]["unit_price"],
identifier=order_element["product"]["identifier"],
)) for order_element in order["order_elements"]
],
) for order in orders
]
def run_homework():
first_order = generate_order()
print(first_order)
cookies = Product(name="Cookies", category_name="Food", unit_price=5)
first_order.add_product_to_order(cookies, quantity=10)
print(first_order)
def run_homework():
first_order = generate_order()
print(first_order)
cookie = Product(name="Ciastko", category_name="Jedzenie", unit_price=4)
first_order.add_product_to_order(cookie, quantity=10)
print(first_order)
def test_findSize(self):
# Given
sut = Product()
sizeA = Size(sizeEU="41.25")
sizeB = Size(sizeEU="38 2/3")
sizeC = Size(sizeEU="39")
sut.addSize(sizeA)
sut.addSize(sizeB)
sut.addSize(sizeC)
# When given size not exists
foundSize = sut.findSize(sizeStr="45")
# Then
self.assertIsNone(foundSize, f"Expected that size was not found and "
f"returned value is None, but got '{foundSize}'")
# When
foundSize = sut.findSize(sizeStr=sizeA.sizeEU)
# Then
self.assertEqual(sizeA, foundSize)
# When
foundSize = sut.findSize(sizeStr=sizeB.sizeEU)
# Then
self.assertEqual(sizeB, foundSize)
# When
foundSize = sut.findSize(sizeStr=sizeC.sizeEU)
# Then
self.assertEqual(sizeC, foundSize)
def test_product_comparision():
parameters = [
("Ciastka", "Jedzenie", 4, "Ciastka", "Jedzenie", 4, True),
("Ciastka", "Jedzenie", 4, "Chleb", "Jedzenie", 4, False),
("Ciastka", "Jedzenie", 4, "Ciastka", "Słodycze", 4, False),
("Ciastka", "Jedzenie", 4, "Ciastka", "Jedzenie", 8, False),
]
for params in parameters:
name, category, price, other_name, other_category, other_price, expected_result = params
result = Product(name, category, price) == Product(other_name, other_category, other_price)
if result == expected_result:
print("OK")
else:
print(f"Błąd! Dla danych {params} wynik porównania jest {result} a powinien być {expected_result}")
def test_run(self):
# Given
shop = Shop(name="Sneak-a-venue Shop unit test",
url=str(self.shopHtmlResponsePath))
product = Product(url=str(self.productHtmlResponsePath))
shop.addProduct(product)
# Results will be written to a temp DB file which path is defined in TempShopRepoHelper.
repoHelper = TempShopRepoHelper(shops=[shop])
async def runner():
# Given
requestMock = RequestMock()
messengerMock = MessengerMock(request=requestMock)
sut = SneakAvenueShopScraper(scrapee=shop,
scrapeeRepo=repoHelper.shopRepo,
request=requestMock,
messenger=messengerMock)
# When / Then
try:
await sut.run()
except Exception as e:
self.fail(
f"Expected test to run without Exception, but raised: {e}")
else:
self.assertEqual(
0, sut._failCount,
f"Expected fail count to be 0, but is {sut._failCount}")
asyncio.run(runner())
def test_addSize_shouldRaiseTypeErrorOnInvalidType(self):
# Given
sut = Product()
invalidType = mock.Mock(spec=dict)
# When / Then
with self.assertRaises(TypeError):
sut.addSize(invalidType)
def test_name_shouldGetAndSet(self):
# Given
sut = Product()
# When Setter
sut.name = "My smart product"
# Then Getter
self.assertEqual("My smart product", sut.name)
def test_url_shouldGetAndSet(self):
# Given
sut = Product()
# When Setter
sut.url = "https://something-to-test/shop"
# Then Getter
self.assertEqual("https://something-to-test/shop", sut.url)
def test_lastScanStamp_shouldGetAndSet(self):
# Given
sut = Product()
# When Setter
sut.lastScanStamp = 123456789.987654321
# Then Getter
self.assertEqual(123456789.987654321, sut.lastScanStamp)
def generate_product(name=None):
category = ProductCategory.JEDZENIE
unit_price = random.randint(MIN_UNIT_PRICE, MAX_UNIT_PRICE)
identifier = random.randint(MIN_IDENTIFIER, MAX_IDENTIFIER)
if name is None:
name = f"Product - {identifier}"
return Product(name, category, unit_price, identifier)
def __init__(self, quantity, name, category, unit_price=None, identifier=None):
if unit_price is None:
unit_price = random.randint(1, 100)
if identifier is None:
identifier = random.randint(1, 100)
self.quantity = quantity
self.product = Product(name=name, category=category, unit_price=unit_price, identifier=identifier)
def test_product_eq():
parameters = [("Ciastka", "Jedzenie", 4, "Ciastka", "Jedzenie", 4, True),
("Ciastka", "Jedzenie", 4, "Ciastka", "Jedzenie", 5, False),
("Ciastka", "Jedzenie", 4, "Ciastka", "Rozrywka", 4, False),
("Ciastka", "Jedzenie", 4, "Piwo", "Jedzenie", 4, False)]
for params in parameters:
name, category_name, price, other_name, other_category_name, other_price, expected_result = params
result = Product(name, category_name,
price) == Product(other_name, other_category_name,
other_price)
if result == expected_result:
print("OK")
else:
print(
f"Błąc! Dla danych {params} wynik: {result} powinien być: {expected_result}"
)
def generate_order(products_number):
order_elements = []
for product_number in range(products_number):
product_name = f"Produkt-{product_number}"
category_name = "Inne"
unit_price = random.randint(1, 30)
product = Product(product_name, category_name, unit_price)
quantity = random.randint(1, 10)
order_elements.append(OrderElement(product, quantity))
return order_elements
def run_homework():
order_over_limit = Order.generate_order(10)
print(order_over_limit)
cookie = Product(name="Ciastko", category_name="Jedzenie", unit_price=4)
order_below_limit = Order.generate_order(4)
order_below_limit.add_product_to_order(cookie, quantity=10)
print(order_below_limit)
order_over_limit.add_product_to_order(cookie, quantity=10)
print(order_over_limit)
def test_sizes_setterShouldRaiseOnInvalidType(self):
# Given
sut = Product()
sizeA = mock.Mock(spec=Size)
invalidType = mock.Mock()
invalidList = [sizeA, invalidType]
# When / Then
with self.assertRaises(TypeError):
sut.sizes = invalidList
def test_getReleaseDate_shouldReturnNoneWhenReleaseStampIsNotSet(self):
# Given
sut = Product()
sut.invalidateReleaseDate()
# When
result = sut.getReleaseDate(forTimezone="America/Indiana/Petersburg", forType=dtt.datetime)
# Then
self.assertEqual(None, result)
def test_invalidateReleaseDate(self):
# Given
sut = Product()
givenDatetime = dtt.datetime(2028, 2, 27, 13, 5, 55)
sut.setReleaseDate(givenDatetime, timezone="Africa/Bissau") # See also: pytz.all_timezones
# When
sut.invalidateReleaseDate()
# Then
self.assertEqual(None, sut.releaseDateStamp)
def generate_order(number_of_products=None):
order_elements = []
if number_of_products is None:
number_of_products = Order.MAX_ORDER_ELEMENTS
for product_number in range(number_of_products):
product_name = f"Produkt-{product_number}"
category_name = "Inne"
unit_price = random.randint(MIN_UNIT_PRICE, MAX_UNIT_PRICE)
product = Product(product_name, category_name, unit_price)
quantity = random.randint(MIN_PRODUCT_QUANTITY, MAX_PRODUCT_QUANTITY)
order_elements.append(OrderElement(product, quantity))
return order_elements
def generate_order(cls, number_of_products):
order_elements = []
for product_number in range(number_of_products):
product_name = f"Produkt-{product_number}"
category_name = "Inne"
unit_price = random.randint(1, 30)
product = Product(product_name, category_name, unit_price)
quantity = random.randint(1, 10)
order_elements.append(OrderElement(product, quantity))
order = Order(client_first_name="Mikołaj", client_last_name="Lewandowski", order_elements=order_elements)
return order
def test_getReleaseDate_shouldRaiseOnInvalidTimezoneString(self):
# Given
sut = Product()
givenDatetime = dtt.datetime(2022, 12, 1, 8, 32, 59)
sut.setReleaseDate(givenDatetime, timezone="Indian/Kerguelen")
# When (forType str)
with self.assertRaises(pytz.UnknownTimeZoneError):
sut.getReleaseDate(forTimezone="Invalid/Something", forType=str)
# When (forType datetime)
with self.assertRaises(pytz.UnknownTimeZoneError):
sut.getReleaseDate(forTimezone="EvenMoreInvalid/Stuff", forType=dtt.datetime)
def generate_order():
order_elements = []
number_of_products = random.randint(1, 10)
for product_number in range(number_of_products):
name = f"Produkt-{product_number}"
product_category = "losowa"
unit_price = random.randint(1, 70)
new_product = Product(name, product_category, unit_price)
quantity = random.randint(1, 10)
order_elements.append(OrderElement(new_product, quantity))
order = Order(client_first_name="Arkadiusz",
client_last_name="Kulewicz",
order_elements=order_elements)
return order
def generate_order():
number_of_product = random.randint(1, 10)
products = []
for product_number in range(number_of_product):
product_name = f"Produkt-{product_number}"
category_name = "Inne"
unit_price = random.randint(1, 30)
product = Product(product_name, category_name, unit_price)
products.append(product)
order = Order(client_first_name="Mikołaj",
client_last_name="Lewandowski",
products=products)
return order
def test_getReleaseDate_shouldReturnReadableString(self):
# Given
sut = Product()
givenDatetime = dtt.datetime(2023, 11, 28, 13, 30, 12)
givenTimezoneString = "Europe/Berlin" # See also: pytz.all_timezones
expectedString = "28.11.2023, 13:30:12"
sut.setReleaseDate(givenDatetime, timezone=givenTimezoneString)
# When
result = sut.getReleaseDate(forTimezone=givenTimezoneString, forType=str)
# Then
self.assertEqual(expectedString, result)