def test_get_birthday_interval_query(self):
start = localdatetime(2000, 3, 1)
end = localdatetime(2000, 3, 25)
query = Individual.get_birthday_query(start, end)
start_year = DateTrunc(u'year', Date(start))
age_in_year = Age(Individual.birth_date,
DateTrunc(u'year', Individual.birth_date))
test_query = (
start_year + age_in_year +
Case(condition=age_in_year < Age(Date(start), start_year),
result=Interval(u'1 year'),
else_=Interval(u'0 year')))
test_query = And(test_query >= Date(start), test_query <= Date(end))
self.assertEquals(query, test_query)
individuals = list(self.store.find(Individual, test_query))
self.assertEquals(len(individuals), 0)
client1 = self.create_client(u'Junio C. Hamano')
client1.person.individual.birth_date = localdate(1972, 10, 15)
client2 = self.create_client(u'Richard Stallman')
client2.person.individual.birth_date = localdate(1989, 3, 7)
client3 = self.create_client(u'Linus Torvalds')
client3.person.individual.birth_date = localdate(2000, 3, 4)
client4 = self.create_client(u'Guido van Rossum')
client4.person.individual.birth_date = localdate(2005, 3, 20)
individuals = list(self.store.find(Individual, test_query))
self.assertEquals(len(individuals), 3)
self.assertTrue(client2.person.individual in individuals)
self.assertTrue(client3.person.individual in individuals)
self.assertTrue(client4.person.individual in individuals)
def test_sale_payment_reserved(self):
sale = self.create_sale()
sale.identifier = 12345
self.add_product(sale, price=100)
method = PaymentMethod.get_by_name(self.store, u'check')
p1 = method.create_payment(
Payment.TYPE_IN, sale.group, sale.branch, 50)
p2 = method.create_payment(
Payment.TYPE_IN, sale.group, sale.branch, 50)
for p in [p1, p2]:
p.set_pending()
p.due_date = localdatetime(2013, 1, 1)
# Pay only one payment so there are 50 paid and 50 confirmed
# (waiting to be paid) totalizing in 100 that's the total here.
p1.pay(paid_date=localdatetime(2013, 1, 2))
total_paid = sale.group.get_total_confirmed_value()
self._create_wizard(sale=sale, total_paid=total_paid)
self._check_wizard('wizard-sale-payment-reserved')
self.assertNotVisible(self.step, ['select_method_holder',
'subtotal_expander'])
with mock.patch.object(self.store, 'commit'):
self._go_to_next()
# Make sure no payments were created
self.assertEqual(set(sale.payments), set([p1, p2]))
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
# Created order, did not send it yet.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
# Created and sent the order.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 56832
order.open_date = localdatetime(2012, 2, 2)
order.send()
# Order arrived at the destination.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20486
order.open_date = localdatetime(2012, 3, 3)
order.send()
order.receive(self.create_employee())
order.receival_date = localdatetime(2012, 3, 4)
def test_create_return_from_execution(self, localnow):
current_branch = api.get_current_branch(self.store)
current_branch.can_execute_foreign_work_orders = True
localnow.return_value = localdatetime(2013, 1, 1)
destination_branch = self.create_branch()
workorders_ids = set()
for i in xrange(10):
wo = self.create_workorder(description=u"Equipment %d" % i)
wo.client = self.create_client()
wo.identifier = 666 + i
wo.open_date = localdatetime(2013, 1, 1)
# Only the 3 finished and with their original branches set to the
# destination_branch will appear on the list
if i < 3:
wo.approve()
elif 3 <= i < 6:
wo.approve()
wo.work()
wo.add_sellable(self.create_sellable())
wo.finish()
elif 6 <= i < 9:
wo.approve()
wo.work()
wo.add_sellable(self.create_sellable())
wo.finish()
wo.branch = destination_branch
workorders_ids.add(wo.id)
editor = WorkOrderPackageSendEditor(self.store)
self.assertInvalid(editor, ['destination_branch'])
self.assertEqual(len(editor.workorders), 0)
editor.destination_branch.update(destination_branch)
self.assertValid(editor, ['destination_branch'])
self.assertEqual(workorders_ids,
set([wo_.id for wo_ in editor.workorders]))
self.assertEqual(editor.model.package_items.count(), 0)
# Only these 2 will be sent
for wo in [editor.workorders[0], editor.workorders[1]]:
wo.will_send = True
# Mimic 'cell-edited' emission
editor.workorders.emit('cell_edited', wo, 'will_send')
self.assertNotSensitive(editor.main_dialog, ['ok_button'])
self.assertInvalid(editor, ['identifier'])
editor.identifier.update(u'123321')
self.assertValid(editor, ['identifier'])
self.assertSensitive(editor.main_dialog, ['ok_button'])
self.check_editor(
editor, 'editor-workorderpackagesend-return-from-execution-create')
with mock.patch.object(editor.model, 'send') as send:
self.click(editor.main_dialog.ok_button)
self.assertEqual(send.call_count, 1)
self.assertEqual(editor.model.package_items.count(), 2)
def testSalePaymentReserved(self):
sale = self.create_sale()
sale.identifier = 12345
self.add_product(sale, price=100)
method = PaymentMethod.get_by_name(self.store, u'check')
p1 = method.create_payment(
Payment.TYPE_IN, sale.group, sale.branch, 50)
p2 = method.create_payment(
Payment.TYPE_IN, sale.group, sale.branch, 50)
for p in [p1, p2]:
p.set_pending()
p.due_date = localdatetime(2013, 1, 1)
# Pay only one payment so there are 50 paid and 50 confirmed
# (waiting to be paid) totalizing in 100 that's the total here.
p1.pay(paid_date=localdatetime(2013, 1, 2))
total_paid = sale.group.get_total_confirmed_value()
self._create_wizard(sale=sale, total_paid=total_paid)
self._check_wizard('wizard-sale-payment-reserved')
self.assertNotVisible(self.step, ['select_method_holder',
'subtotal_expander'])
self._go_to_next()
# Make sure no payments were created
self.assertEqual(set(sale.payments), set([p1, p2]))
def test_show(self, localnow):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
localnow.return_value = localdatetime(2013, 2, 1)
sellable = self.create_sellable(code=u'Code')
workorder = self.create_workorder(description=u'Test equipment')
workorder.identifier = 666
workorder.supplier_order = u"A1234"
workorder.client = self.create_client()
workorder.sellable = sellable
workorder.category = WorkOrderCategory(store=self.store,
name=u'Categoty XXX')
workorder.defect_reported = u"Defect reported"
# Create the editor and check initial state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-initial')
self.assertEqual(editor.supplier_order.read(), u'A1234')
self.assertSensitive(editor, ['client'])
self.assertSensitive(editor, ['category', 'category_create'])
self.assertSensitive(editor, ['supplier_order'])
workorder.defect_detected = u"Defect detected"
workorder.estimated_hours = 10
workorder.estimated_hours = 100
workorder.estimated_start = localdatetime(2013, 1, 1)
workorder.estimated_finish = localdatetime(2013, 1, 2)
workorder.approve(self.current_user)
_adjust_history_date(workorder)
# Create another editor to check approved state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-approved')
workorder.add_sellable(self.create_sellable(description=u"Product A"),
price=99,
quantity=2)
workorder.add_sellable(self.create_sellable(description=u"Product B"),
price=5,
quantity=100)
workorder.work(self.current_branch, self.current_user)
_adjust_history_date(workorder)
# Create another editor to check work in progress state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-in-progress')
workorder.finish(self.current_branch, self.current_user)
_adjust_history_date(workorder)
# Create another editor to check finished state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-finished')
for item in workorder.order_items:
item.reserve(self.current_user, item.quantity)
workorder.close(self.current_branch, self.current_user)
_adjust_history_date(workorder)
# Create another editor to check closed state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-closed')
def __init__(self):
self.api = mock.Mock()
self.api.get_current_branch = get_current_branch
self.DatabaseSettings = FakeDatabaseSettings
self.StoqConfig = FakeStoqConfig
self.datetime = mock.MagicMock(datetime)
self.datetime.datetime.today.return_value = localdatetime(2012, 1, 1)
self.datetime.datetime.now.return_value = localdatetime(2012, 1, 1)
self.datetime.date.today.return_value = localdate(2012, 1, 1).date()
def __init__(self):
self.api = mock.Mock()
self.api.get_current_branch = get_current_branch
self.DatabaseSettings = FakeDatabaseSettings
self.StoqConfig = FakeStoqConfig
self.datetime = mock.MagicMock(datetime)
self.datetime.datetime.today.return_value = localdatetime(2012, 1, 1)
self.datetime.datetime.now.return_value = localdatetime(2012, 1, 1)
self.datetime.date.today.return_value = localdate(2012, 1, 1).date()
def test_close_returned_in_consignment_wizard(self, run_dialog, info):
purchase_item = self.create_purchase_order_item()
self.create_receiving_order_item(purchase_item=purchase_item)
# Create storable.
product = purchase_item.sellable.product
Storable(store=self.store, product=product)
storable = product.storable
branch = purchase_item.order.branch
storable.increase_stock(5, branch,
StockTransactionHistory.TYPE_INITIAL, None,
self.current_user)
stock_quantity = storable.get_stock_item(branch, None).quantity
self.assertEqual(stock_quantity, 5)
purchase_item.quantity_received = 5
purchase_item.order.status = PurchaseOrder.ORDER_CONSIGNED
purchase_item.order.identifier = 334
purchase_item.order.open_date = localdatetime(2012, 1, 1)
purchase_item.order.expected_receival_date = localdatetime(2012, 2, 2)
wizard = CloseInConsignmentWizard(self.store)
step = wizard.get_current_step()
self.click(step.search.search_button)
product_stock_item = self.store.find(ProductStockItem,
storable=storable).one()
self.check_wizard(wizard, 'wizard-return-consignment-selection-step')
order_view = step.search.results[0]
step.search.results.select(order_view)
self.click(wizard.next_button)
step = wizard.get_current_step()
# Select consignment.
step.consignment_items.emit('row_activated', step.consignment_items[0])
self.assertEqual(run_dialog.call_count, 1)
args, kwargs = run_dialog.call_args
editor, parent, store, item = args
self.assertEqual(editor, InConsignmentItemEditor)
self.assertEqual(parent, wizard)
self.assertEqual(item, purchase_item)
self.assertTrue(store is not None)
# Return the total received.
purchase_item.quantity_returned = 5
self.click(wizard.next_button)
# After return. Item quantity in stock must be decreased.
stock_quantity = storable.get_stock_item(branch, None).quantity
self.assertEqual(stock_quantity, 0)
self.check_wizard(wizard,
'wizard-close-returned-in-consignment-confirm',
[wizard.retval, purchase_item, product_stock_item])
def test_complete_receiving_multiple_purchases(self):
branch = api.get_current_branch(self.store)
# Create purchase order 1
product1 = self.create_product(description=u'Product 1', storable=True)
order1 = self.create_purchase_order(branch=branch)
order1.identifier = 10023
order1.open_date = localdatetime(2012, 10, 9)
order1.expected_receival_date = localdatetime(2012, 9, 25)
order1.add_item(product1.sellable, 7)
order1.status = PurchaseOrder.ORDER_PENDING
order1.confirm()
# And purchase order 2
product2 = self.create_product(description=u'Product 2', storable=True)
order2 = self.create_purchase_order(branch=branch,
supplier=order1.supplier)
order2.identifier = 10024
order2.open_date = localdatetime(2012, 10, 9)
order2.expected_receival_date = localdatetime(2012, 9, 25)
order2.add_item(product2.sellable, 5)
order2.status = PurchaseOrder.ORDER_PENDING
order2.confirm()
# Now to the wizard
wizard = ReceivingOrderWizard(self.store)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
self.click(step.search.search_button)
# Select both purchase orders. There is one bug in kiwi that we cannot
# select all at once, so thats why we are using this private api.
step.search.results._treeview.get_selection().select_all()
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard,
'receiving-order-multiple-purchase-selection-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-order-multiple-product-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
step.invoice_slave.invoice_number.update(10094)
step.invoice_slave.freight.update(159)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-order-multiple-invoice-step')
with contextlib.nested(mock.patch.object(self.store, 'commit')):
# Confirm
self.click(wizard.next_button)
self.assertEqual(product1.storable.get_balance_for_branch(branch), 7)
self.assertEqual(product2.storable.get_balance_for_branch(branch), 5)
def test_show(self, localnow):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
localnow.return_value = localdatetime(2013, 2, 1)
sellable = self.create_sellable(code=u'Code')
workorder = self.create_workorder(description=u'Test equipment')
workorder.identifier = 666
workorder.supplier_order = u"A1234"
workorder.client = self.create_client()
workorder.sellable = sellable
workorder.category = WorkOrderCategory(store=self.store,
name=u'Categoty XXX')
workorder.defect_reported = u"Defect reported"
# Create the editor and check initial state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-initial')
self.assertEqual(editor.supplier_order.read(), u'A1234')
self.assertSensitive(editor, ['client'])
self.assertSensitive(editor, ['category', 'category_create'])
self.assertSensitive(editor, ['supplier_order'])
workorder.defect_detected = u"Defect detected"
workorder.estimated_hours = 10
workorder.estimated_hours = 100
workorder.estimated_start = localdatetime(2013, 1, 1)
workorder.estimated_finish = localdatetime(2013, 1, 2)
workorder.approve()
_adjust_history_date(workorder)
# Create another editor to check approved state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-approved')
workorder.add_sellable(self.create_sellable(description=u"Product A"),
price=99, quantity=2)
workorder.add_sellable(self.create_sellable(description=u"Product B"),
price=5, quantity=100)
workorder.work()
_adjust_history_date(workorder)
# Create another editor to check work in progress state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-in-progress')
workorder.finish()
_adjust_history_date(workorder)
# Create another editor to check finished state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-finished')
for item in workorder.order_items:
item.reserve(item.quantity)
workorder.close()
_adjust_history_date(workorder)
# Create another editor to check closed state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-closed')
def test_close_returned_in_consignment_wizard(self, run_dialog, info):
purchase_item = self.create_purchase_order_item()
self.create_receiving_order_item(purchase_item=purchase_item)
# Create storable.
product = purchase_item.sellable.product
Storable(store=self.store, product=product)
storable = product.storable
branch = purchase_item.order.branch
storable.increase_stock(5, branch,
StockTransactionHistory.TYPE_INITIAL, None)
stock_quantity = storable.get_stock_item(branch, None).quantity
self.assertEqual(stock_quantity, 5)
purchase_item.quantity_received = 5
purchase_item.order.status = PurchaseOrder.ORDER_CONSIGNED
purchase_item.order.identifier = 334
purchase_item.order.open_date = localdatetime(2012, 1, 1)
purchase_item.order.expected_receival_date = localdatetime(2012, 2, 2)
wizard = CloseInConsignmentWizard(self.store)
step = wizard.get_current_step()
self.click(step.search.search_button)
product_stock_item = self.store.find(ProductStockItem,
storable=storable).one()
self.check_wizard(wizard, 'wizard-return-consignment-selection-step')
order_view = step.search.results[0]
step.search.results.select(order_view)
self.click(wizard.next_button)
step = wizard.get_current_step()
# Select consignment.
step.consignment_items.emit('row_activated', step.consignment_items[0])
self.assertEqual(run_dialog.call_count, 1)
args, kwargs = run_dialog.call_args
editor, parent, store, item = args
self.assertEqual(editor, InConsignmentItemEditor)
self.assertEqual(parent, wizard)
self.assertEqual(item, purchase_item)
self.assertTrue(store is not None)
# Return the total received.
purchase_item.quantity_returned = 5
self.click(wizard.next_button)
# After return. Item quantity in stock must be decreased.
stock_quantity = storable.get_stock_item(branch, None).quantity
self.assertEqual(stock_quantity, 0)
self.check_wizard(wizard,
'wizard-close-returned-in-consignment-confirm',
[wizard.retval, purchase_item, product_stock_item])
def test_complete_receiving_multiple_purchases(self):
branch = api.get_current_branch(self.store)
# Create purchase order 1
product1 = self.create_product(description=u'Product 1', storable=True)
order1 = self.create_purchase_order(branch=branch)
order1.identifier = 10023
order1.open_date = localdatetime(2012, 10, 9)
order1.expected_receival_date = localdatetime(2012, 9, 25)
order1.add_item(product1.sellable, 7)
order1.status = PurchaseOrder.ORDER_PENDING
order1.confirm()
# And purchase order 2
product2 = self.create_product(description=u'Product 2', storable=True)
order2 = self.create_purchase_order(branch=branch,
supplier=order1.supplier)
order2.identifier = 10024
order2.open_date = localdatetime(2012, 10, 9)
order2.expected_receival_date = localdatetime(2012, 9, 25)
order2.add_item(product2.sellable, 5)
order2.status = PurchaseOrder.ORDER_PENDING
order2.confirm()
# Now to the wizard
wizard = ReceivingOrderWizard(self.store)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
self.click(step.search.search_button)
# Select both purchase orders. There is one bug in kiwi that we cannot
# select all at once, so thats why we are using this private api.
step.search.results._treeview.get_selection().select_all()
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-order-multiple-purchase-selection-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-order-multiple-product-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
step.invoice_slave.invoice_number.update(10094)
step.invoice_slave.freight.update(159)
self.check_wizard(wizard, 'receiving-order-multiple-invoice-step')
with contextlib.nested(
mock.patch.object(self.store, 'commit')):
# Confirm
self.click(wizard.next_button)
self.assertEquals(product1.storable.get_balance_for_branch(branch), 7)
self.assertEquals(product2.storable.get_balance_for_branch(branch), 5)
def _create_domain(self):
client = self.create_client(name=u'Dane Cook')
loan = self.create_loan(client=client)
self.create_loan_item(loan=loan)
loan.identifier = 54952
loan.open_date = localdatetime(2012, 1, 1)
client = self.create_client(name=u'Carmen Sandiego')
loan = self.create_loan(client=client)
self.create_loan_item(loan=loan)
loan.identifier = 45978
loan.open_date = localdatetime(2012, 2, 2)
def _create_domain(self):
client = self.create_client(name=u'Dane Cook')
loan = self.create_loan(client=client)
self.create_loan_item(loan=loan)
loan.identifier = 54952
loan.open_date = localdatetime(2012, 1, 1)
client = self.create_client(name=u'Carmen Sandiego')
loan = self.create_loan(client=client)
self.create_loan_item(loan=loan)
loan.identifier = 45978
loan.open_date = localdatetime(2012, 2, 2)
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
responsible = self.create_employee()
other_branch = Branch.get_active_remote_branches(
self.store, self.current_branch)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send(self.current_user)
# One that we have already received
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 56832
order.open_date = localdatetime(2012, 2, 2)
order.send(self.current_user)
order.receive(self.current_user, responsible)
order.receival_date = localdatetime(2012, 2, 2)
# One that we have sent but is not received yet
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20486
order.open_date = localdatetime(2012, 3, 3)
order.send(self.current_user)
# One that we have sent and is recived
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20489
order.open_date = localdatetime(2012, 3, 4)
order.send(self.current_user)
order.receive(self.current_user, responsible)
order.receival_date = localdatetime(2012, 3, 5)
# And another one that is cancelled
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20491
order.open_date = localdatetime(2012, 4, 5)
order.send(self.current_user)
order.cancel(self.current_user,
responsible,
'Cancelled due something',
self.current_branch,
cancel_date=localdatetime(2012, 4, 6))
def testCompleteReceiving(self, yesno, run_dialog, warning):
yesno.return_value = True
run_dialog.return_value = Settable(skip=Decimal('0'))
order = self.create_purchase_order()
order.identifier = 65432
order.open_date = localdatetime(2012, 10, 9)
order.expected_receival_date = localdatetime(2012, 9, 25)
sellable = self.create_sellable()
order.add_item(sellable, 1)
order.status = PurchaseOrder.ORDER_PENDING
order.confirm()
wizard = ReceivingOrderWizard(self.store)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
self.click(step.search.search_button)
order_view = step.search.results[0]
step.search.results.select(order_view)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'purchase-selection-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-order-product-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
step.invoice_slave.invoice_number.update(1)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-invoice-step')
module = 'stoqlib.gui.events.ReceivingOrderWizardFinishEvent.emit'
with mock.patch(module) as emit:
self.click(wizard.next_button)
self.assertEquals(emit.call_count, 1)
args, kwargs = emit.call_args
self.assertTrue(isinstance(args[0], ReceivingOrder))
yesno.assert_called_once_with('Do you want to print the labels for '
'the received products?',
gtk.RESPONSE_YES, 'Print labels',
"Don't print")
run_dialog.assert_called_once_with(SkipLabelsEditor, wizard,
self.store)
warning.assert_called_once_with('It was not possible to print the '
'labels. The template file was '
'not found.')
def testCompleteReceiving(self, yesno, run_dialog, warning):
yesno.return_value = True
run_dialog.return_value = Settable(skip=Decimal('0'))
order = self.create_purchase_order()
order.identifier = 65432
order.open_date = localdatetime(2012, 10, 9)
order.expected_receival_date = localdatetime(2012, 9, 25)
sellable = self.create_sellable()
order.add_item(sellable, 1)
order.status = PurchaseOrder.ORDER_PENDING
order.confirm()
wizard = ReceivingOrderWizard(self.store)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
self.click(step.search.search_button)
order_view = step.search.results[0]
step.search.results.select(order_view)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'purchase-selection-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-order-product-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
step.invoice_slave.invoice_number.update(1)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'receiving-invoice-step')
module = 'stoqlib.gui.events.ReceivingOrderWizardFinishEvent.emit'
with mock.patch(module) as emit:
self.click(wizard.next_button)
self.assertEquals(emit.call_count, 1)
args, kwargs = emit.call_args
self.assertTrue(isinstance(args[0], ReceivingOrder))
yesno.assert_called_once_with(
'Do you want to print the labels for '
'the received products?', gtk.RESPONSE_YES, 'Print labels',
"Don't print")
run_dialog.assert_called_once_with(SkipLabelsEditor, wizard,
self.store)
warning.assert_called_once_with('It was not possible to print the '
'labels. The template file was '
'not found.')
def test_cancel_order_nfce_plugin_active(self, get_plugin_manager,
run_dialog):
dest_branch = Branch.get_active_remote_branches(self.store)[0]
source_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
get_plugin_manager.is_active.return_value = True
run_dialog.return_value = Note()
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
msg_text = u"This will cancel the transfer. Are you sure?"
run_dialog.assert_called_once_with(
NoteEditor, dialog, order.store, model=None,
message_text=msg_text, label_text=u"Reason", mandatory=True,
ok_button_label=u"Cancel transfer",
cancel_button_label=u"Don't cancel",
min_length=15)
self.assertEqual(order.status, TransferOrder.STATUS_CANCELLED)
self.assertEqual(order.receival_date, None)
def test_receive_order(self, print_report, yesno):
yesno.retval = True
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
# Created and sent the order.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.click(dialog.print_button)
print_report.assert_called_once_with(dialog.report_class, dialog.model)
self.assertSensitive(dialog, ['receive_button'])
with mock.patch.object(self.store, 'commit'):
self.click(dialog.receive_button)
yesno.assert_called_once_with(u'Receive the order?', Gtk.ResponseType.YES,
u'Receive', u"Don't receive")
self.assertEqual(order.status, order.STATUS_RECEIVED)
self.assertEqual(order.cancel_date, None)
def testCreate(self):
branches = self.store.find(Branch)
dialog = OpenInventoryDialog(self.store, branches)
d = localdatetime(2010, 01, 30, 12, 33)
dialog.open_time.set_text(d.strftime("%X"))
self.check_editor(dialog, 'dialog-open-inventory')
def _check_start_step(self, uitest=''):
start_step = self.wizard.get_current_step()
start_step.quote_deadline.update(localdatetime(2020, 1, 1))
start_step.quote_group.set_text("12345")
if uitest:
self.check_wizard(self.wizard, uitest)
self.click(self.wizard.next_button)
def create_individual(self, person=None):
from stoqlib.domain.person import Individual, Person
if person is None:
person = Person(name=u'individual', store=self.store)
return Individual(person=person,
birth_date=localdatetime(1970, 1, 1),
store=self.store)
def test_receive_order(self, print_report, yesno):
yesno.retval = True
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
# Created and sent the order.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.click(dialog.print_button)
print_report.assert_called_once_with(dialog.report_class, dialog.model)
self.assertSensitive(dialog, ['receive_button'])
with mock.patch.object(self.store, 'commit'):
self.click(dialog.receive_button)
yesno.assert_called_once_with(u'Receive the order?', gtk.RESPONSE_YES,
u'Receive', u"Don't receive")
self.assertEquals(order.status, order.STATUS_RECEIVED)
self.assertEquals(order.cancel_date, None)
def test_undo_with_pending_payment(self):
# First, we create a sale_item and relate it to a sale.
sale_item = self.create_sale_item()
sale = sale_item.sale
self.add_payments(sale)
sale.order()
# The sale is then completed and confirmed with its payment confirmed as well.
sale.confirm()
# Now, we create a return adapter to make the actual return.
returned_sale = sale.create_sale_return_adapter()
returned_sale.confirm(self.create_user())
# A pending payment is then made for it to be cancelled when the sale return is
# actually undone.
payment = self.create_payment(date=localdatetime(2012, 1, 1),
value=sale_item.price,
group=sale.group)
payment.set_pending()
# There should be 2 payments at this point.
n_payments1 = sale.payments.count()
returned_sale.undo(reason=u'teste')
# This test evaluates if the pending payment was actually cancelled and that, at
# any point around the undoing of the sale return, no payments are added or
# removed.
self.assertEqual(payment.status, Payment.STATUS_CANCELLED)
self.assertEqual(n_payments1, 2)
self.assertEqual(sale.group.payments.count(), 2)
def test_undo_with_pending_payment(self):
# First, we create a sale_item and relate it to a sale.
sale_item = self.create_sale_item()
sale = sale_item.sale
self.add_payments(sale)
sale.order(self.current_user)
# The sale is then completed and confirmed with its payment confirmed as well.
sale.confirm(self.current_user)
# Now, we create a return adapter to make the actual return.
returned_sale = sale.create_sale_return_adapter(
self.current_branch, self.current_user, self.current_station)
returned_sale.confirm(self.create_user())
# A pending payment is then made for it to be cancelled when the sale return is
# actually undone.
payment = self.create_payment(date=localdatetime(2012, 1, 1),
value=sale_item.price,
group=sale.group)
payment.set_pending()
# There should be 2 payments at this point.
n_payments1 = sale.payments.count()
returned_sale.undo(self.current_user, reason='teste')
# This test evaluates if the pending payment was actually cancelled and that, at
# any point around the undoing of the sale return, no payments are added or
# removed.
self.assertEqual(payment.status, Payment.STATUS_CANCELLED)
self.assertEqual(n_payments1, 2)
self.assertEqual(sale.group.payments.count(), 2)
def test_cancel_order_nfce_plugin_active(self, get_plugin_manager,
run_dialog):
dest_branch = Branch.get_active_remote_branches(
self.store, api.get_current_branch(self.store))[0]
source_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send(self.current_user)
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
get_plugin_manager.is_active.return_value = True
run_dialog.return_value = Note()
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
msg_text = u"This will cancel the transfer. Are you sure?"
run_dialog.assert_called_once_with(
NoteEditor,
dialog,
order.store,
model=None,
message_text=msg_text,
label_text=u"Reason",
mandatory=True,
ok_button_label=u"Cancel transfer",
cancel_button_label=u"Don't cancel",
min_length=15)
self.assertEqual(order.status, TransferOrder.STATUS_CANCELLED)
self.assertEqual(order.receival_date, None)
def _create_domain(self):
self.clean_domain([ReceivingOrderItem, ReceivingOrder])
supplier_a = self.create_supplier(u'Mark')
purchase_order_a = self.create_purchase_order(supplier=supplier_a)
order_a = self.create_receiving_order(purchase_order=purchase_order_a)
supplier_b = self.create_supplier(u'Dominique')
purchase_order_b = self.create_purchase_order(supplier=supplier_b)
order_b = self.create_receiving_order(purchase_order=purchase_order_b)
order_a.purchase.identifier = 81954
order_a.receival_date = localdatetime(2012, 1, 1)
order_b.purchase.identifier = 78526
order_b.receival_date = localdatetime(2012, 2, 2)
def _check_start_step(self, uitest=""):
start_step = self.wizard.get_current_step()
start_step.quote_deadline.update(localdatetime(2020, 1, 1))
start_step.quote_group.set_text("12345")
if uitest:
self.check_wizard(self.wizard, uitest)
self.click(self.wizard.next_button)
def _create_domain(self):
self.clean_domain([ReceivingOrderItem, PurchaseReceivingMap, ReceivingOrder])
supplier_a = self.create_supplier(u'Mark')
purchase_order_a = self.create_purchase_order(supplier=supplier_a)
order_a = self.create_receiving_order(purchase_order=purchase_order_a)
supplier_b = self.create_supplier(u'Dominique')
purchase_order_b = self.create_purchase_order(supplier=supplier_b)
order_b = self.create_receiving_order(purchase_order=purchase_order_b)
purchase_order_a.identifier = 81954
order_a.receival_date = localdatetime(2012, 1, 1)
purchase_order_b.identifier = 78526
order_b.receival_date = localdatetime(2012, 2, 2)
def test_show(self, localnow):
localnow.return_value = localdatetime(2013, 2, 1)
workorder = self.create_workorder(equipment=u'Test equipment')
workorder.identifier = 666
workorder.client = self.create_client()
workorder.category = WorkOrderCategory(store=self.store,
name=u'Categoty XXX')
workorder.defect_reported = u"Defect reported"
# Create the editor and check initial state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-initial')
workorder.defect_detected = u"Defect detected"
workorder.estimated_hours = 10
workorder.estimated_hours = 100
workorder.estimated_start = localdatetime(2013, 1, 1)
workorder.estimated_finish = localdatetime(2013, 1, 2)
workorder.approve()
_adjust_history_date(workorder)
# Create another editor to check approved state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-approved')
workorder.add_sellable(self.create_sellable(description=u"Product A"),
price=99,
quantity=2)
workorder.add_sellable(self.create_sellable(description=u"Product B"),
price=5,
quantity=100)
workorder.work()
_adjust_history_date(workorder)
# Create another editor to check work in progress state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-in-progress')
workorder.finish()
_adjust_history_date(workorder)
# Create another editor to check finished state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-finished')
workorder.close()
_adjust_history_date(workorder)
# Create another editor to check closed state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-closed')
def testCreate(self, localnow):
localnow.return_value = localdatetime(2013, 1, 1)
destination_branch = self.create_branch()
workorders_ids = set()
for i in xrange(10):
wo = self.create_workorder(u"Equipment %d" % i)
wo.client = self.create_client()
wo.identifier = 666 + i
wo.open_date = localdatetime(2013, 1, 1)
# Only the first 6 will appear on the list. Half of them as
# approved and half of them as finished.
if i < 3:
wo.approve()
workorders_ids.add(wo.id)
elif i < 6:
wo.approve()
wo.start()
wo.add_sellable(self.create_sellable())
wo.finish()
workorders_ids.add(wo.id)
editor = WorkOrderPackageSendEditor(self.store)
self.assertEqual(workorders_ids,
set([wo.id for wo in editor.workorders]))
self.assertEqual(editor.model.package_items.count(), 0)
# Only these 2 will be sent
for wo in [editor.workorders[0], editor.workorders[1]]:
wo.will_send = True
# Mimic 'cell-edited' emission
editor.workorders.emit('cell_edited', wo, 'will_send')
self.assertEqual(editor.model.package_items.count(), 2)
self.assertNotSensitive(editor.main_dialog, ['ok_button'])
self.assertInvalid(editor, ['identifier', 'destination_branch'])
editor.identifier.update(u'123321')
editor.destination_branch.update(destination_branch)
self.assertValid(editor, ['identifier', 'destination_branch'])
self.assertSensitive(editor.main_dialog, ['ok_button'])
self.check_editor(editor, 'editor-workorderpackagesend-create')
with mock.patch.object(editor.model, 'send') as send:
self.click(editor.main_dialog.ok_button)
send.assert_called_once()
def testCreate(self, localnow):
localnow.return_value = localdatetime(2013, 1, 1)
destination_branch = self.create_branch()
workorders_ids = set()
for i in xrange(10):
wo = self.create_workorder(u"Equipment %d" % i)
wo.client = self.create_client()
wo.identifier = 666 + i
wo.open_date = localdatetime(2013, 1, 1)
# Only the first 6 will appear on the list. Half of them as
# approved and half of them as finished.
if i < 3:
wo.approve()
workorders_ids.add(wo.id)
elif i < 6:
wo.approve()
wo.start()
wo.add_sellable(self.create_sellable())
wo.finish()
workorders_ids.add(wo.id)
editor = WorkOrderPackageSendEditor(self.store)
self.assertEqual(workorders_ids,
set([wo.id for wo in editor.workorders]))
self.assertEqual(editor.model.package_items.count(), 0)
# Only these 2 will be sent
for wo in [editor.workorders[0], editor.workorders[1]]:
wo.will_send = True
# Mimic 'cell-edited' emission
editor.workorders.emit('cell_edited', wo, 'will_send')
self.assertEqual(editor.model.package_items.count(), 2)
self.assertNotSensitive(editor.main_dialog, ['ok_button'])
self.assertInvalid(editor, ['identifier', 'destination_branch'])
editor.identifier.update(u'123321')
editor.destination_branch.update(destination_branch)
self.assertValid(editor, ['identifier', 'destination_branch'])
self.assertSensitive(editor.main_dialog, ['ok_button'])
self.check_editor(editor, 'editor-workorderpackagesend-create')
with mock.patch.object(editor.model, 'send') as send:
self.click(editor.main_dialog.ok_button)
send.assert_called_once()
def test_complete(self):
station = self.create_station()
today = localdate(2007, 1, 1)
reduction_date = localdatetime(2007, 1, 1, 23, 59)
day = FiscalDayHistory(store=self.store,
emission_date=today,
station=station,
serial=u'Stoqlib test serial',
serial_id=1,
coupon_start=1,
coupon_end=23,
crz=18,
cro=25,
period_total=Decimal("456.00"),
total=Decimal("123141.00"),
reduction_date=reduction_date)
for code, value, type in [(u'2500', Decimal("123.00"), u'ICMS'),
(u'F', Decimal("789.00"), u'ICMS')]:
FiscalDayTax(fiscal_day_history=day,
code=code,
value=value,
type=type,
store=self.store)
branch = get_current_branch(self.store)
user = self.create_employee()
branch.manager = user
manager = branch.manager.person
company = branch.person.company
address = branch.person.get_main_address()
start = today + relativedelta(day=1)
end = today + relativedelta(day=31)
s = SintegraFile()
s.add_header(company.get_cnpj_number(), u'110042490114',
branch.get_description(), address.get_city(),
address.get_state(),
branch.person.get_fax_number_number(), start, end)
# if we don't a street number, use zero for sintegra
s.add_complement_header(address.street, address.streetnumber or 0,
address.complement, address.district,
address.get_postal_code_number(), manager.name,
branch.person.get_phone_number_number())
for item in self.store.find(FiscalDayHistory):
s.add_fiscal_coupon(item.emission_date, item.serial,
item.serial_id, item.coupon_start,
item.coupon_end, item.cro, item.crz,
item.period_total, item.total)
for tax in item.taxes:
s.add_fiscal_tax(item.emission_date, item.serial, tax.code,
tax.value)
s.close()
try:
compare_sintegra_file(s, 'sintegra')
except AssertionError as e:
self.fail(e)
def test_create_repeated_month(self):
p = self.create_payment()
p.description = u'Rent'
p.category = self.create_payment_category()
payments = Payment.create_repeated(self.store, p, INTERVALTYPE_MONTH,
localdate(2012, 1, 1).date(),
localdate(2012, 12, 31).date())
self.assertEquals(len(payments), 11)
self.assertEquals(p.due_date, localdatetime(2012, 1, 1))
self.assertEquals(p.description, u'1/12 Rent')
self.assertEquals(payments[0].due_date, localdatetime(2012, 2, 1))
self.assertEquals(payments[1].due_date, localdatetime(2012, 3, 1))
self.assertEquals(payments[10].due_date, localdatetime(2012, 12, 1))
self.assertEquals(payments[0].description, u'2/12 Rent')
self.assertEquals(payments[10].description, u'12/12 Rent')
def test_show(self, localnow):
localnow.return_value = localdatetime(2013, 2, 1)
workorder = self.create_workorder(equipment=u'Test equipment')
workorder.identifier = 666
workorder.client = self.create_client()
workorder.category = WorkOrderCategory(store=self.store,
name=u'Categoty XXX')
workorder.defect_reported = u"Defect reported"
# Create the editor and check initial state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-initial')
workorder.defect_detected = u"Defect detected"
workorder.estimated_hours = 10
workorder.estimated_hours = 100
workorder.estimated_start = localdatetime(2013, 1, 1)
workorder.estimated_finish = localdatetime(2013, 1, 2)
workorder.approve()
_adjust_history_date(workorder)
# Create another editor to check approved state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-approved')
workorder.add_sellable(self.create_sellable(description=u"Product A"),
price=99, quantity=2)
workorder.add_sellable(self.create_sellable(description=u"Product B"),
price=5, quantity=100)
workorder.work()
_adjust_history_date(workorder)
# Create another editor to check work in progress state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-in-progress')
workorder.finish()
_adjust_history_date(workorder)
# Create another editor to check finished state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-finished')
workorder.close()
_adjust_history_date(workorder)
# Create another editor to check closed state
editor = WorkOrderEditor(self.store, model=workorder)
self.check_editor(editor, 'editor-workorder-show-closed')
def test_complete_reconciliation(self):
sellable = self.create_sellable()
purchase_item = self.create_purchase_order_item(sellable=sellable)
purchase = purchase_item.order
purchase.identifier = 65432
purchase.group = None
receiving = self.create_receiving_order(purchase_order=purchase)
receiving.identifier = 45633
receiving.receival_date = localdatetime(2012, 10, 9)
receiving_item = self.create_receiving_order_item(
receiving_order=receiving, purchase_item=purchase_item, quantity=2)
receiving.receiving_invoice = None
wizard = PurchaseReconciliationWizard(self.store)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
self.click(step.search.search_button)
order_view = step.search.results[0]
step.search.results.select(order_view)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard,
'wizard-reconciliation-receiving-selection-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard,
'wizard-reconciliation-check-receiving-cost-step')
receiving_item.cost = 130
step._update_view()
self.assertEqual(step.total_received.read(), 260)
self.click(wizard.next_button)
self.assertEqual(type(wizard.model), ReceivingInvoice)
invoice = wizard.model
invoice.identifier = 22222
# Test cell data func
renderer = Gtk.CellRendererText()
col = step.purchase_items.get_columns()[6]
item = step.purchase_items[0]
step._on_purchase_items__cell_data_func(col, renderer, item, 'aa')
self.assertTrue(renderer.get_property('editable-set'))
self.assertTrue(renderer.get_property('editable'))
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
step.invoice_slave.invoice_number.update(1)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard,
'wizard-reconciliation-receiving-invoice-step')
self.click(wizard.next_button)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'wizard-reconciliation-payment-step')
with contextlib.nested(mock.patch.object(self.store, 'close'),
mock.patch.object(self.store,
'commit')) as (close, commit):
self.click(wizard.next_button)
def testCreateRepeatedMonth(self):
p = self.create_payment()
p.description = u'Rent'
p.category = self.create_payment_category()
payments = Payment.create_repeated(self.store, p,
INTERVALTYPE_MONTH,
localdate(2012, 1, 1).date(),
localdate(2012, 12, 31).date())
self.assertEquals(len(payments), 11)
self.assertEquals(p.due_date, localdatetime(2012, 1, 1))
self.assertEquals(p.description, u'1/12 Rent')
self.assertEquals(payments[0].due_date, localdatetime(2012, 2, 1))
self.assertEquals(payments[1].due_date, localdatetime(2012, 3, 1))
self.assertEquals(payments[10].due_date, localdatetime(2012, 12, 1))
self.assertEquals(payments[0].description, u'2/12 Rent')
self.assertEquals(payments[10].description, u'12/12 Rent')
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
source_branch = self.create_branch(u'Riachuelo')
dest_branch = self.create_branch(u'Marisa')
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
source_branch = self.create_branch(u'Opera Rock')
dest_branch = self.create_branch(u'Cavalera')
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 56832
order.open_date = localdatetime(2012, 2, 2)
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
responsible = self.create_employee()
other_branch = Branch.get_active_remote_branches(self.store)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send()
# One that we have already received
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 56832
order.open_date = localdatetime(2012, 2, 2)
order.send()
order.receive(responsible)
order.receival_date = localdatetime(2012, 2, 2)
# One that we have sent but is not received yet
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20486
order.open_date = localdatetime(2012, 3, 3)
order.send()
# One that we have sent and is recived
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20489
order.open_date = localdatetime(2012, 3, 4)
order.send()
order.receive(responsible)
order.receival_date = localdatetime(2012, 3, 5)
# And another one that is cancelled
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20491
order.open_date = localdatetime(2012, 4, 5)
order.send()
order.cancel(responsible, 'Cancelled due something',
cancel_date=localdatetime(2012, 4, 6))
def create_receivable_sale(self):
sale = self.create_sale()
sale.identifier = 12345
self.add_product(sale)
sale.order()
payment = self.add_payments(sale, method_type=u'bill')[0]
payment.identifier = 67890
sale.confirm()
payment.due_date = localdatetime(2012, 1, 1)
# payment.paid_date = datetime.datetime(2012, 2, 2)
return sale, payment
def create_receivable_sale(self):
sale = self.create_sale()
sale.identifier = 12345
self.add_product(sale)
sale.order()
payment = self.add_payments(sale, method_type=u'bill')[0]
payment.identifier = 67890
sale.confirm()
payment.due_date = localdatetime(2012, 1, 1)
# payment.paid_date = datetime.datetime(2012, 2, 2)
return sale, payment
def test_dont_cancel_order(self, run_dialog):
order = self.create_transfer_order()
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
run_dialog.return_value = False
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
self.assertEqual(order.status, TransferOrder.STATUS_SENT)
def test_dont_cancel_order(self, run_dialog):
order = self.create_transfer_order()
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send(self.current_user)
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
run_dialog.return_value = False
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
self.assertEqual(order.status, TransferOrder.STATUS_SENT)
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
other_branch = Branch.get_active_remote_branches(self.store)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch, dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send()
def create_receivable_sale(self):
sale = self.create_sale()
sale.open_date = datetime.datetime(2013, 1, 1)
sale.identifier = 12345
self.add_product(sale)
sale.order(self.current_user)
payment = self.add_payments(sale, method_type=u'bill',
date=datetime.datetime(2013, 1, 1))[0]
payment.identifier = 67890
sale.confirm(self.current_user)
payment.due_date = localdatetime(2012, 1, 1)
return sale, payment
def test_create_repeated_month(self):
p = self.create_payment()
p.description = u"Rent"
p.category = self.create_payment_category()
with self.assertRaises(AssertionError):
Payment.create_repeated(
self.store, p, INTERVALTYPE_MONTH, localdate(2012, 1, 1).date(), localdate(2012, 1, 1).date()
)
payments = Payment.create_repeated(
self.store, p, INTERVALTYPE_MONTH, localdate(2012, 1, 1).date(), localdate(2012, 12, 31).date()
)
self.assertEquals(len(payments), 11)
self.assertEquals(p.due_date, localdatetime(2012, 1, 1))
self.assertEquals(p.description, u"1/12 Rent")
self.assertEquals(payments[0].due_date, localdatetime(2012, 2, 1))
self.assertEquals(payments[1].due_date, localdatetime(2012, 3, 1))
self.assertEquals(payments[10].due_date, localdatetime(2012, 12, 1))
self.assertEquals(payments[0].description, u"2/12 Rent")
self.assertEquals(payments[10].description, u"12/12 Rent")
def test_confirm(self, info):
loan = self.create_loan()
loan.identifier = 9999
loan.client = self.create_client()
loan_item = self.create_loan_item(loan=loan, quantity=10)
total_sales = self.store.find(Sale, status=Sale.STATUS_ORDERED).count()
wizard = CloseLoanWizard(self.store)
step = wizard.get_current_step()
loan.open_date = localdatetime(2012, 1, 1, 12, 0)
self.click(step.search.search_button)
loan_view = step.search.results[0]
step.search.results.select(loan_view)
self.check_wizard(wizard, 'close-loan-wizard-select-loan-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
step.validate(True)
objectlist = step.slave.klist
self.assertNotSensitive(wizard, ['next_button'])
loan_item.return_quantity = 2
loan_item.sale_quantity = 2
objectlist.update(loan_item)
step.validate(True)
self.assertSensitive(wizard, ['next_button'])
module = 'stoqlib.gui.events.CloseLoanWizardFinishEvent.emit'
with mock.patch(module) as emit:
self.click(wizard.next_button)
self.assertEquals(emit.call_count, 1)
args, kwargs = emit.call_args
# The event emits a list of loans
self.assertTrue(isinstance(args[0], list))
self.assertTrue(isinstance(args[0][0], Loan))
self.check_wizard(wizard, 'close-loan-wizard-loan-item-selection-step',
wizard.retval + [loan_item])
new_total_sales = self.store.find(Sale,
status=Sale.STATUS_ORDERED).count()
self.assertEquals(total_sales + 1, new_total_sales)
# Checks if stock is correct. 10 items were loaned, 2 were
# returned and 2 were sold, so those 2 should be have been returned to
# branch's stock
branch = loan.branch
self.assertEquals(loan_item.storable.get_balance_for_branch(branch), 2)
info.assert_called_once_with(
_('Close loan details...'),
_("A sale was "
"created from loan items. You can confirm "
"that sale in the Till application later."))
def test_transfer_receipt_cancelled(self):
source_branch = self.create_branch(name=u'Stoq Roupas')
destination_branch = self.create_branch(name=u'Stoq Sapatos')
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=destination_branch)
for i in range(5):
self.create_transfer_order_item(order)
order.send()
order.cancel(self.create_employee())
order.cancel_date = localdatetime(2012, 12, 12)
self._diff_expected(TransferOrderReceipt,
'transfer-receipt-cancelled', order)
def test_transfer_receipt_cancelled(self):
source_branch = self.create_branch(name=u'Stoq Roupas')
destination_branch = self.create_branch(name=u'Stoq Sapatos')
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=destination_branch)
for i in range(5):
self.create_transfer_order_item(order)
order.send()
order.cancel(self.create_employee())
order.cancel_date = localdatetime(2012, 12, 12)
self._diff_expected(TransferOrderReceipt, 'transfer-receipt-cancelled',
order)
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
other_branch = Branch.get_active_remote_branches(self.store)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send()
def test_confirm(self, info):
loan = self.create_loan()
loan.identifier = 9999
loan.client = self.create_client()
loan_item = self.create_loan_item(loan=loan, quantity=10)
total_sales = self.store.find(Sale, status=Sale.STATUS_ORDERED).count()
wizard = CloseLoanWizard(self.store)
step = wizard.get_current_step()
loan.open_date = localdatetime(2012, 1, 1, 12, 0)
self.click(step.search.search_button)
loan_view = step.search.results[0]
step.search.results.select(loan_view)
self.check_wizard(wizard, 'close-loan-wizard-select-loan-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
step.validate(True)
objectlist = step.slave.klist
self.assertNotSensitive(wizard, ['next_button'])
loan_item.return_quantity = 2
loan_item.sale_quantity = 2
objectlist.update(loan_item)
step.validate(True)
self.assertSensitive(wizard, ['next_button'])
module = 'stoqlib.gui.events.CloseLoanWizardFinishEvent.emit'
with mock.patch(module) as emit:
self.click(wizard.next_button)
self.assertEquals(emit.call_count, 1)
args, kwargs = emit.call_args
# The event emits a list of loans
self.assertTrue(isinstance(args[0], list))
self.assertTrue(isinstance(args[0][0], Loan))
self.check_wizard(wizard,
'close-loan-wizard-loan-item-selection-step',
wizard.retval + [loan_item])
new_total_sales = self.store.find(Sale, status=Sale.STATUS_ORDERED).count()
self.assertEquals(total_sales + 1, new_total_sales)
# Checks if stock is correct. 10 items were loaned, 2 were
# returned and 2 were sold, so those 2 should be have been returned to
# branch's stock
branch = loan.branch
self.assertEquals(loan_item.storable.get_balance_for_branch(branch), 2)
info.assert_called_once_with('Close loan details...',
"A sale was created from loan items. "
"You can confirm that sale in the Till "
"application later.")
def test_cancel_order_on_dest_branch(self):
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
# Destination branch should not cancel the transfer
self.assertFalse(dialog.cancel_button.get_visible())
def test_cancel_order_on_dest_branch(self):
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
# Destination branch should not cancel the transfer
self.assertFalse(dialog.cancel_button.get_visible())
def test_get_birthday_interval_query(self):
start = localdatetime(2000, 3, 1)
end = localdatetime(2000, 3, 25)
query = Individual.get_birthday_query(start, end)
start_year = DateTrunc(u'year', Date(start))
age_in_year = Age(Individual.birth_date,
DateTrunc(u'year', Individual.birth_date))
test_query = (
start_year + age_in_year +
Case(condition=age_in_year < Age(Date(start), start_year),
result=Interval(u'1 year'),
else_=Interval(u'0 year'))
)
test_query = And(test_query >= Date(start),
test_query <= Date(end))
self.assertEquals(query, test_query)
individuals = list(self.store.find(Individual, test_query))
self.assertEquals(len(individuals), 0)
client1 = self.create_client(u'Junio C. Hamano')
client1.person.individual.birth_date = localdate(1972, 10, 15)
client2 = self.create_client(u'Richard Stallman')
client2.person.individual.birth_date = localdate(1989, 3, 7)
client3 = self.create_client(u'Linus Torvalds')
client3.person.individual.birth_date = localdate(2000, 3, 4)
client4 = self.create_client(u'Guido van Rossum')
client4.person.individual.birth_date = localdate(2005, 3, 20)
individuals = list(self.store.find(Individual, test_query))
self.assertEquals(len(individuals), 3)
self.assertTrue(client2.person.individual in individuals)
self.assertTrue(client3.person.individual in individuals)
self.assertTrue(client4.person.individual in individuals)
def test_show_with_sale(self, localnow):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
localnow.return_value = localdatetime(2013, 12, 1)
# Create a work order with sale
workorder = self.create_workorder(description=u'Test equipment')
workorder.identifier = 1234
workorder.sale = self.create_sale()
workorder.client = self.create_client()
# Create the editor
editor = WorkOrderEditor(self.store, model=workorder)
self.assertNotSensitive(editor, ['client'])
self.assertNotSensitive(editor, ['category', 'category_create'])
self.check_editor(editor, 'editor-workorder-with-sale-show')
def test_show_with_sale(self, localnow):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
localnow.return_value = localdatetime(2013, 12, 1)
# Create a work order with sale
workorder = self.create_workorder(description=u'Test equipment')
workorder.identifier = 1234
workorder.sale = self.create_sale()
workorder.client = self.create_client()
# Create the editor
editor = WorkOrderEditor(self.store, model=workorder)
self.assertNotSensitive(editor, ['client'])
self.assertNotSensitive(editor, ['category', 'category_create'])
self.check_editor(editor, 'editor-workorder-with-sale-show')
