def test_total_amount(self):
order = Order()
order.add_product(Product(name='Product 1',
price=10,
product_type=ProductType.DIGITAL),
quantity=2)
order.add_product(Product(name='Product 2',
price=15,
product_type=ProductType.DIGITAL),
quantity=2)
total = order.total_amount()
self.assertEqual(total, 50)
def test_process_multiple(self):
email = EmailCommand()
email.process = MagicMock()
discount = DiscountCommand()
discount.process = MagicMock()
ship_label = ShipLabelCommand()
ship_label.process = MagicMock()
subscription = SubscriptionCommand()
subscription.process = MagicMock()
order_item = OrderItem(product=Product(name='Book',
price=10,
product_type=ProductType.BOOK),
quantity=1)
OrderItemProcessor(order_item) \
.add(email) \
.add(ship_label) \
.add(discount) \
.add(subscription) \
.process()
email.process.assert_called_with()
ship_label.process.assert_called_with()
discount.process.assert_called_with()
subscription.process.assert_called_with()
def test_should_calculate_price_with_15_percent_discount(self):
products = [Product(PRICE, "DIS_15_ABCD", PRODUCT)]
cart = ShoppingCart(CUSTOMER, products)
order = cart.checkout()
self.assertEqual(85.00, order.total)
def test_total(self):
item = OrderItem(
Product(name='Product 1',
price=10.0,
product_type=ProductType.DIGITAL), 2)
self.assertEqual(item.total(), 20)
def get_products():
print('PYFLASKHERO_DB_USER: '******'PYFLASKHERO_DB_USER'])
print('PYFLASKHERO_DB_PORT: ' + os.environ['PYFLASKHERO_DB_PORT'])
print('PYFLASKHERO_DB_USER: '******'PYFLASKHERO_DB_USER'])
print('PYFLASKHERO_DB_PWD: ' + os.environ['PYFLASKHERO_DB_PWD'])
print('PYFLASKHERO_DB_NAME: ' + os.environ['PYFLASKHERO_DB_NAME'])
mariadb_connection = mariadb.connect(
host=os.environ['PYFLASKHERO_DB_HOST'],
port=os.environ['PYFLASKHERO_DB_PORT'],
user=os.environ['PYFLASKHERO_DB_USER'],
password=os.environ['PYFLASKHERO_DB_PWD'],
database=os.environ['PYFLASKHERO_DB_NAME'])
cursor = mariadb_connection.cursor()
cursor.execute(
"SELECT product_name as name, product_manufacturer as manufacturer , submission_date FROM products"
)
products = []
for name, manufacturer, submission_date in cursor:
print('Found something')
print('product : ' + name)
products.append(Product(name, manufacturer, submission_date))
for product in products:
print(product)
mariadb_connection.close()
return products
def test_add_product(self):
order = Order()
order.add_product(
Product(name='Product 1',
price=10.0,
product_type=ProductType.DIGITAL), 1)
order.add_product(
Product(name='Product 2',
price=11.0,
product_type=ProductType.BOOK), 1)
order.add_product(
Product(name='Product 3',
price=12.0,
product_type=ProductType.PHYSICAL), 1)
self.assertEqual(len(order.items), 3)
def test_should_calculate_loyalty_points_with_15_percent_discount(self):
products = [Product(PRICE, "DIS_15_ABCD", PRODUCT)]
cart = ShoppingCart(CUSTOMER, products)
order = cart.checkout()
self.assertEqual(6, order.loyalty_points)
def test_create_invalid_product_type(self):
order_item = OrderItem(Product(name=None,
price=None,
product_type=None),
quantity=1)
with self.assertRaises(Exception):
ProductTypeStrategyFactory.create(order_item)
def insert(self, description):
try:
new_product = Product(description=description)
self.ses.add(new_product)
self.ses.commit()
return new_product
except:
print("An exception occurred")
def test_create_book(self):
order_item = OrderItem(Product(name='Book',
price=1,
product_type=ProductType.BOOK),
quantity=1)
strategy = ProductTypeStrategyFactory.create(order_item)
self.assertIsInstance(strategy, ProductBookStrategy)
def test_create_physical(self):
order_item = OrderItem(Product(name='Physical',
price=1,
product_type=ProductType.PHYSICAL),
quantity=1)
strategy = ProductTypeStrategyFactory.create(order_item)
self.assertIsInstance(strategy, ProductPhysicalStrategy)
def test_create_membership(self):
order_item = OrderItem(Product(name='Membership',
price=1,
product_type=ProductType.MEMBERSHIP),
quantity=1)
strategy = ProductTypeStrategyFactory.create(order_item)
self.assertIsInstance(strategy, ProductMembershipStrategy)
def test_create_digital(self):
order_item = OrderItem(Product(name='Digital',
price=1,
product_type=ProductType.DIGITAL),
quantity=1)
strategy = ProductTypeStrategyFactory.create(order_item)
self.assertIsInstance(strategy, ProductDigitalStrategy)
def main():
product1 = Product(10.0, "DIS_10_PRODUCT1", "product 1")
product2 = Product(20.0, "DIS_10_PRODUCT2", "product 2")
products = [product1, product2]
customer = Customer("A Customer")
shopping_cart = ShoppingCart(customer, products)
product3 = Product(30.0, "DIS_1_PRODUCT3", "product 3")
shopping_cart.add_product(product3)
print(shopping_cart)
order = shopping_cart.checkout()
print(order)
def test_process_subscription(self):
subscription = SubscriptionCommand()
subscription.process = MagicMock()
order_item = OrderItem(product=Product(name='Book',
price=10,
product_type=ProductType.BOOK),
quantity=1)
OrderItemProcessor(order_item).add(subscription).process()
subscription.process.assert_called_with()
def test_process_discount(self):
discount = DiscountCommand()
discount.process = MagicMock()
order_item = OrderItem(product=Product(name='Book',
price=10,
product_type=ProductType.BOOK),
quantity=1)
OrderItemProcessor(order_item).add(discount).process()
discount.process.assert_called_with()
def test_process_email(self):
email = EmailCommand()
email.process = MagicMock()
order_item = OrderItem(product=Product(name='Book',
price=10,
product_type=ProductType.BOOK),
quantity=1)
OrderItemProcessor(order_item).add(email).process()
email.process.assert_called_with()
def test_process_ship_label(self):
ship_label = ShipLabelCommand()
ship_label.process = MagicMock()
order_item = OrderItem(product=Product(name='Book',
price=10,
product_type=ProductType.BOOK),
quantity=1)
OrderItemProcessor(order_item).add(ship_label).process()
ship_label.process.assert_called_with()
def main():
coke = Product('Coke', 1.00)
validator = CoinValidator()
vending_machine = VendingMachine(coke, validator, coke.price)
coin = Coin(5.670)
vending_machine.insert_coins(coin)
print(vending_machine.DISPLAY)
vending_machine.insert_coins(coin)
vending_machine.insert_coins(coin)
print(vending_machine.DISPLAY)
vending_machine.insert_coins(coin)
print(vending_machine.DISPLAY)
def test_process(self):
book = Product(name='Awesome book', price=15.0, product_type=ProductType.MEMBERSHIP)
customer = Customer(nome='Fulano', address=Address(zipcode='45678-979', street='Street', city='City'))
book_order = Order(customer)
book_order.add_product(book, 2)
credit_card = CreditCard().fetch_by_hash('43567890-987654367')
order = OrderService().process(book_order, credit_card)
self.assertIsNotNone(order)
self.assertIsNotNone(order.payment)
self.assertEqual(order.payment.payment_method, credit_card)
def test_pay(self):
now = time.time()
customer = Customer(nome='Fulano', address=Address(zipcode='45678-979', street='Street', city='City'))
order = Order(customer)
order.add_product(product=Product(name='Book', price=10, product_type=ProductType.BOOK), quantity=1)
payment = Payment(order=order, payment_method=CreditCard().fetch_by_hash('12345657890'))
payment.pay()
self.assertIsNotNone(payment)
self.assertIsNotNone(payment.order)
self.assertIsNotNone(payment.paid_at)
self.assertGreaterEqual(now, payment.paid_at)
self.assertIsNotNone(payment.authorization_number)
self.assertEqual(payment.amount, order.total_amount())
self.assertIsNotNone(payment.invoice)
def setup(self):
self.coin = Quarter()
self.product = Product('Coke', .50)
self.validator = CoinValidator()
self.vending_machine = VendingMachine(self.product, self.validator,
.50)
def test_input_coins_updates_display_when_payment_is_suffice(self):
product = Product('Coke', .25)
vending_machine = VendingMachine(product, self.validator, .25)
vending_machine.insert_coins(self.coin)
assert vending_machine.DISPLAY == THANK_YOU
from src.model.customer import Customer, Address
from src.model.order import Order
from src.model.payment_method import CreditCard
from src.model.product import Product, ProductType
from src.service.order import OrderService
if __name__ == '__main__':
book = Product(name='Awesome book',
price=15.0,
product_type=ProductType.MEMBERSHIP)
customer = Customer(nome='Fulano',
address=Address(zipcode='45678-979',
street='Street',
city='City'))
book_order = Order(customer=customer)
book_order.add_product(book, 2)
OrderService().process(book_order,
CreditCard().fetch_by_hash('43567890-987654367'))
def step_impl(context, product, price):
product = Product(product, float(price))
validator = CoinValidator()
context.vending_machine = VendingMachine(product, validator, product.price)
def test_should_return_not_equal_when_different_price(self):
self.assertFalse(TestsFixture.PRODUCT_1.__eq__(Product("Cola", 2, 0)))
def test_should_return_not_equal_when_different_name(self):
self.assertFalse(TestsFixture.PRODUCT_1.__eq__(Product("Candy", 1, 0)))
def test_should_return_same_hash_for_same_object(self):
self.assertEqual(TestsFixture.PRODUCT_1.__hash__(),
Product("Cola", 1, 0).__hash__())
if __name__ == '__main__':
unittest.main()
def order_item(context, price):
validator = CoinValidator()
product = Product('Item', float(price))
context.vending_machine = VendingMachine(product, validator, float(price))
def test_should_return_equals_when_same_name_and_price(self):
self.assertTrue(TestsFixture.PRODUCT_1.__eq__(Product("Cola", 1, 0)))
