Exemple #1
0
def test_calculate_prices_3(order_3):
    expected = Order(
        barista='txema',
        chips=[
            Chips(
                type='deluxe',
                size='grandes',
                price=3.5,
            ),
            Chips(
                type='gajo',
                size='grandes',
                price=3.5,
            ),
        ],
        drinks=[
            Drink(
                type='burribeer',
                price=2.5,
            ),
        ],
        price=9.5,
        promotions=[],
    )
    result = orders.calculate_prices(order=order_3)
    assert_dicts(original=result.dict(), expected=expected.dict())
Exemple #2
0
def test_calculate_prices_promotion_jarramania_3(order_promotion_jarramania):
    expected = Order(
        barista='txema',
        chips=[
            Chips(
                type='deluxe',
                size='grandes',
                price=3.5,
            ),
        ],
        drinks=[
            Drink(
                type='burribeer',
                price=2.5,
            ),
            Drink(
                type='burribeer',
                price=2.5,
            ),
        ],
        price=8.5,
        promotions=[],
    )
    assert PromotionJarramania().is_applicable(order_promotion_jarramania) is False
    result = orders.calculate_prices(order=order_promotion_jarramania)
    assert_dicts(original=result.dict(), expected=expected.dict())
Exemple #3
0
def add_order(order: Order, ) -> Order:
    """
    Add a new document at mongoDB.

    :param Order order: order
    :return Order: order inserted
    """
    collection = _get_mongo_db_client()[os.getenv('MONGODB_COLLECTION')]
    now = datetime.now()
    order.dt_created = now.strftime("%Y-%m-%d %H:%M:%S")
    collection.insert_one(
        document=dict(_id=ObjectId.from_datetime(now), **order.dict()))
    return order
Exemple #4
0
def order_2():
    return Order(
        barista='txema',
        hamburgers=[
            Hamburger(
                meats=[
                    Meat(
                        type='cerdo',
                        size='250g',
                        cooked='al punto',
                    ),
                    Meat(
                        type='cerdo',
                        size='380g',
                        cooked='al punto',
                    ),
                ],
                extra_tomato=ExtraTomato(type='normal', ),
            ),
        ],
        chips=[
            Chips(
                type='de la abuela',
                size='grandes',
            ),
        ],
        drinks=[
            Drink(type='burribeer', ),
        ],
    )
Exemple #5
0
def test_calculate_prices_2(order_2):
    expected = Order(
        barista='txema',
        hamburgers=[
            Hamburger(
                meats=[
                    Meat(
                        type='cerdo',
                        size='250g',
                        cooked='al punto',
                        price=2.5,
                    ),
                    Meat(
                        type='cerdo',
                        size='380g',
                        cooked='al punto',
                        price=3.5,
                    ),
                ],
                extra_tomato=ExtraTomato(
                    type='normal',
                    price=1.0,
                ),
                price=12.0 * (100 - 15) / 100,
            ),
        ],
        chips=[
            Chips(
                type='de la abuela',
                size='grandes',
                price=3.5,
            ),
        ],
        drinks=[
            Drink(
                type='burribeer',
                price=2.5,
            ),
        ],
        price=16.2,
        promotions=['burrimenu'],
    )
    result = orders.calculate_prices(order=order_2)
    assert_dicts(original=result.dict(), expected=expected.dict())
def test_calculate_prices_promotion_burrimenu(order_promotion_menu):
    expected = Order(
        barista='txema',
        hamburgers=[
            Hamburger(
                meats=[
                    Meat(
                        type='pollo',
                        size='250g',
                        cooked='al punto',
                        price=2.5,
                    )
                ],
                extra_cheese=ExtraCheese(
                    type='cheddar',
                    price=1.5,
                ),
                extra_tomato=ExtraTomato(
                    type='normal',
                    price=1.0,
                ),
                price=10.0 * (100 - 15) / 100,
            ),
        ],
        chips=[
            Chips(
                type='gajo',
                size='pequeñas',
                price=2.5,
            ),
        ],
        drinks=[
            Drink(
                type='burribeer',
                price=2.5,
            ),
        ],
        price=13.5,
        promotions=['burrimenu'],
    )
    assert PromotionBurrimenu().is_applicable(
        order=order_promotion_menu) is True
    result = orders.calculate_prices(order=order_promotion_menu)
    assert_dicts(original=result.dict(), expected=expected.dict())
Exemple #7
0
def order_promotion_jarramania():
    return Order(
        barista='txema',
        chips=[
            Chips(
                type='deluxe',
                size='grandes',
            ),
        ],
        drinks=[
            Drink(type='burribeer', ),
            Drink(type='burribeer', ),
        ],
    )
Exemple #8
0
def test_calculate_prices_1(order_1):
    expected = Order(
        barista='txema',
        hamburgers=[
            Hamburger(
                meats=[
                    Meat(
                        type='pollo',
                        size='250g',
                        cooked='al punto',
                        price=2.5,
                    )
                ],
                extra_cheese=ExtraCheese(
                    type='cheddar',
                    price=1.5,
                ),
                extra_tomato=ExtraTomato(
                    type='normal',
                    price=1.0,
                ),
                price=10.0,
            ),
        ],
        chips=[
            Chips(
                type='gajo',
                size='pequeñas',
                price=2.5,
            ),
        ],
        price=12.5,
        promotions=[],
    )
    result = orders.calculate_prices(order=order_1)
    assert_dicts(original=result.dict(), expected=expected.dict())
Exemple #9
0
def order_3():
    return Order(
        barista='txema',
        chips=[
            Chips(
                type='deluxe',
                size='grandes',
            ),
            Chips(
                type='gajo',
                size='grandes',
            ),
        ],
        drinks=[
            Drink(type='burribeer', ),
        ],
    )
Exemple #10
0
def order_1():
    return Order(
        barista='txema',
        hamburgers=[
            Hamburger(
                meats=[Meat(
                    type='pollo',
                    size='250g',
                    cooked='al punto',
                )],
                extra_cheese=ExtraCheese(type='cheddar', ),
                extra_tomato=ExtraTomato(type='normal', ),
            ),
        ],
        chips=[
            Chips(
                type='gajo',
                size='pequeñas',
            ),
        ],
        promotions=[],
    )
Exemple #11
0
def calculate_prices(order: Order, ) -> Order:
    """
    This method calculates and add the prices of all items and total.

    :param Order order: list of order.
    """
    for drink in order.drinks:
        drink.price = PriceDrink().calculate(drink=drink)

    for chips in order.chips:
        chips.price = PriceChips().calculate(chips=chips)

    for hamburger in order.hamburgers:
        hamburger.price = PriceHamburger().calculate(hamburger=hamburger)

    if PromotionBurrimenu().is_applicable(order=order):
        PromotionBurrimenu().apply(order=order)

    if PromotionEuromania().is_applicable(order=order):
        PromotionEuromania().apply(order=order)

    order.price = PriceTotal().calculate(order=order)

    return order