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_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)
