def test_return_with_credit(self): branch = get_current_branch(self.store) sale_item = self.create_sale_item() sale = sale_item.sale sellable = sale_item.sellable self.create_storable(product=sellable.product, branch=branch, stock=10) payments = self.add_payments(sale, method_type=u'bill', installments=2) payments[0].status = Payment.STATUS_PENDING self.add_payments(sale, method_type=u'money') sale.order() sale.confirm() rsale = ReturnedSale(branch=branch, sale=sale, store=self.store) ReturnedSaleItem(store=self.store, returned_sale=rsale, sale_item=sale_item, quantity=1) # Create an unused to test the removal of unused items, # should probably be removed. ReturnedSaleItem(store=self.store, returned_sale=rsale, sale_item=sale_item, quantity=0) rsale.return_(u'credit')
def test_get_total(self): sale_item = self.create_sale_item() returned_item = ReturnedSaleItem(store=self.store, sale_item=sale_item) returned_item.quantity = 2 returned_item.price = 100 self.assertEquals(returned_item.get_total(), 200)
def test_sale_total(self): branch = self.create_branch() rsale = ReturnedSale(branch=branch, store=self.store) self.assertEquals(rsale.sale_total, currency(0)) sale = self.create_sale(branch=branch) sellable = self.add_product(sale) self.add_payments(sale) rsale1 = ReturnedSale(branch=branch, sale=sale, store=self.store) rsale2 = ReturnedSale(branch=branch, sale=sale, store=self.store) self.assertEquals(rsale1.sale_total, currency(0)) item = ReturnedSaleItem(store=self.store, returned_sale=rsale2, sellable=sellable) item.quantity = 10 item.price = 10 self.assertEquals(rsale1.sale_total, currency(-100))
def test_total(self): sale_item = self.create_sale_item() item = ReturnedSaleItem(store=self.store, sale_item=sale_item) item.quantity = 1 self.assertEquals(item.total, 100) item.price = 10 self.assertEquals(item.total, 10) item.quantity = 20 self.assertEquals(item.total, 200)
def test_total(self): sale_item = self.create_sale_item() item = ReturnedSaleItem(store=self.store, sale_item=sale_item) item.quantity = 1 self.assertEqual(item.total, 100) item.price = 10 self.assertEqual(item.total, 10) item.quantity = 20 self.assertEqual(item.total, 200)
def test_trade_without_sale(self): # With discount returned_sale = ReturnedSale(store=self.store, station=self.current_station, responsible=self.current_user, branch=self.current_branch) storable = self.create_storable(branch=self.current_branch, stock=10) ReturnedSaleItem(store=self.store, quantity=1, price=10, sellable=storable.product.sellable, returned_sale=returned_sale) new_sale = self.create_sale() returned_sale.new_sale = new_sale balance_before_trade = storable.get_balance_for_branch( self.current_branch) with self.sysparam(USE_TRADE_AS_DISCOUNT=True): returned_sale.trade(self.current_user) self.assertEqual(new_sale.discount_value, currency(10)) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(storable.get_balance_for_branch(self.current_branch), balance_before_trade + 1) # Without discount returned_sale2 = ReturnedSale(store=self.store, station=self.current_station, responsible=self.current_user, branch=self.current_branch) storable = self.create_storable(branch=self.current_branch, stock=10) ReturnedSaleItem(store=self.store, quantity=1, price=10, sellable=storable.product.sellable, returned_sale=returned_sale2) new_sale = self.create_sale() returned_sale2.new_sale = new_sale balance_before_trade = storable.get_balance_for_branch( self.current_branch) returned_sale2.trade(self.current_user) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(new_sale.discount_value, currency(0)) group = new_sale.group payment = group.payments[0] self.assertEqual(group.payments.count(), 1) self.assertEqual(payment.value, returned_sale2.returned_total) self.assertEqual(storable.get_balance_for_branch(self.current_branch), balance_before_trade + 1)
def test_get_client_credit_transactions(self): method = self.store.find(PaymentMethod, method_name=u'credit').one() client = self.create_client() sale = self.create_sale(client=client) self.add_product(sale) self.add_payments(sale) sale.order() sale.confirm() returned_sale = ReturnedSale(sale=sale, branch=get_current_branch(self.store), store=self.store) ReturnedSaleItem(sale_item=list(sale.get_items())[0], quantity=1, returned_sale=returned_sale, store=self.store) sale.return_(returned_sale) payment = self.create_payment(payment_type=Payment.TYPE_OUT, value=100, method=method, group=sale.group) payment.set_pending() payment.pay() payment_domain_list = list(client.get_credit_transactions()) self.assertTrue(len(payment_domain_list) == 1) payment_domain = payment_domain_list[0] self.assertEquals(payment.identifier, payment_domain.identifier) self.assertEquals(payment.paid_date, payment_domain.paid_date) self.assertEquals(payment.description, payment_domain.description) self.assertEquals(payment.paid_value, payment_domain.paid_value)
def test_return_unpaid_with_credit(self): sale_item = self.create_sale_item() sale = sale_item.sale sellable = sale_item.sellable self.create_storable(product=sellable.product, branch=self.current_branch, stock=10) self.add_payments(sale, method_type=u'bill', installments=1) sale.order(self.current_user) sale.confirm(self.current_user) rsale = ReturnedSale(branch=self.current_branch, station=self.current_station, sale=sale, store=self.store) ReturnedSaleItem(store=self.store, returned_sale=rsale, sale_item=sale_item, quantity=1) # Before the return there is not out payment self.assertIsNone( sale.group.payments.find(payment_type=Payment.TYPE_OUT).one()) rsale.return_(self.current_user, 'credit') # There should be one payment with a credit for the returned value self.assertIsNotNone( sale.group.payments.find(payment_type=Payment.TYPE_OUT).one())
def test_credit_account_balance(self): method = self.store.find(PaymentMethod, method_name=u'credit').one() client = self.create_client() sale = self.create_sale(client=client) self.add_product(sale) self.add_payments(sale) sale.order() sale.confirm() returned_sale = ReturnedSale(sale=sale, branch=get_current_branch(self.store), store=self.store) ReturnedSaleItem(sale_item=list(sale.get_items())[0], quantity=1, returned_sale=returned_sale, store=self.store) sale.return_(returned_sale) payment = self.create_payment(payment_type=Payment.TYPE_OUT, value=100, method=method, group=sale.group) payment.set_pending() payment.pay() self.assertEquals(client.credit_account_balance, 100)
def test_add_item(self, branch=None): sale_item = self.create_sale_item() branch = branch or self.create_branch() item = ReturnedSaleItem(store=self.store, sale_item=sale_item) rsale = ReturnedSale(store=self.store, branch=branch) rsale.add_item(item)
def test_constructor(self): with self.assertRaisesRegexp( ValueError, "A sale_item or a sellable is mandatory to create this object"): ReturnedSaleItem(store=self.store) sellable = self.create_sellable() sale_item = self.create_sale_item() with self.assertRaisesRegexp( ValueError, "sellable must be the same as sale_item.sellable"): ReturnedSaleItem(sellable=sellable, sale_item=sale_item, store=self.store) returned_item = self.create_returned_sale_item() self.assertIsNotNone(returned_item.icms_info) self.assertIsNotNone(returned_item.ipi_info)
def get_order_item(self, sellable, price, quantity): item = ReturnedSaleItem( store=self.store, quantity=quantity, price=price, sellable=sellable, returned_sale=self.model, ) _adjust_returned_sale_item(item) return item
def test_returned_sale_totals(self): # Verificar esse funcionamento no Stoq sale = self.create_sale() product = self.create_product(price=100) sale_item = sale.add_sellable(product.sellable) self.add_payments(sale) sale.order() sale.confirm() returned_sale = ReturnedSale(branch=sale.branch, sale=sale, store=self.store) ReturnedSaleItem(returned_sale=returned_sale, sale_item=sale_item, quantity=1) self.assertEquals(returned_sale.invoice_subtotal, 100) self.assertEquals(returned_sale.invoice_total, 100)
def get_order_item(self, sellable, price, quantity, batch=None): if batch is not None: batch = StorableBatch.get_or_create( self.store, storable=sellable.product_storable, batch_number=batch) item = ReturnedSaleItem( store=self.store, quantity=quantity, price=price, sellable=sellable, batch=batch, returned_sale=self.model, ) _adjust_returned_sale_item(item) return item
def test_return_on_another_branch(self): # Branch where the sale was created sale_branch = self.current_branch # Branch where the sale was returned return_branch = self.create_branch() product = self.create_product(branch=sale_branch, stock=2) client = self.create_client() # Creating a sale on sale_branch sale = self.create_sale(branch=sale_branch, client=client) sale_item = sale.add_sellable(sellable=product.sellable) # Adding payments and confirming the sale payments = self.add_payments(sale, method_type=u'bill', installments=2) payments[0].status = Payment.STATUS_PENDING self.add_payments(sale, method_type=u'money') sale.order(self.current_user) sale.confirm(self.current_user) # Creating the returned_sale rsale = ReturnedSale(branch=return_branch, station=self.current_station, sale=sale, store=self.store) ReturnedSaleItem(store=self.store, returned_sale=rsale, sale_item=sale_item, quantity=1) rsale.return_(self.current_user, 'credit') # Checking the status of sale and returned_sale self.assertEqual(rsale.status, ReturnedSale.STATUS_PENDING) self.assertEqual(sale.status, Sale.STATUS_RETURNED) # Checking the quantity on sale_branch self.assertEqual(product.storable.get_balance_for_branch(sale_branch), 1) # We should not increase the stock of that product on return_branch self.assertEqual( product.storable.get_balance_for_branch(return_branch), 0)
def test_trade_on_another_branch(self): sale_branch = self.current_branch return_branch = self.create_branch() product = self.create_product(branch=sale_branch, stock=5) sale = self.create_sale(branch=sale_branch) sale_item = sale.add_sellable(sellable=product.sellable) storable = product.storable sale.order(self.current_user) self.add_payments(sale) sale.confirm(self.current_user) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) returned_sale = ReturnedSale(store=self.store, station=self.current_station, responsible=self.current_user, sale=sale, branch=return_branch) ReturnedSaleItem(store=self.store, quantity=1, price=10, sale_item=sale_item, returned_sale=returned_sale) new_sale = self.create_sale(branch=return_branch) returned_sale.new_sale = new_sale returned_sale.trade(self.current_user) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_PENDING) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) self.assertEqual(storable.get_balance_for_branch(return_branch), 0) # This sale is returned in the return_branch, so the stock for the original sale branch is # the same, but the return branch has a new stock item returned_sale.confirm(self.current_user) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) self.assertEqual(storable.get_balance_for_branch(return_branch), 1)
def test_trade_on_another_branch(self): sale_branch = get_current_branch(self.store) return_branch = self.create_branch() current_user = get_current_user(self.store) product = self.create_product(branch=sale_branch, stock=5) sale = self.create_sale(branch=sale_branch) sale_item = sale.add_sellable(sellable=product.sellable) storable = product.storable sale.order() self.add_payments(sale) sale.confirm() self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) returned_sale = ReturnedSale(store=self.store, responsible=current_user, sale=sale, branch=return_branch) ReturnedSaleItem(store=self.store, quantity=1, price=10, sale_item=sale_item, returned_sale=returned_sale) new_sale = self.create_sale(branch=return_branch) returned_sale.new_sale = new_sale returned_sale.trade() self.assertEqual(returned_sale.status, ReturnedSale.STATUS_PENDING) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) self.assertEqual(storable.get_balance_for_branch(return_branch), 0) returned_sale.confirm(current_user) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(storable.get_balance_for_branch(sale_branch), 5) self.assertEqual(storable.get_balance_for_branch(return_branch), 0)
def test_add_item(self): sale_item = self.create_sale_item() item = ReturnedSaleItem(store=self.store, sale_item=sale_item) rsale = ReturnedSale(store=self.store) rsale.add_item(item)