def test_wizard_with_cost_center(self, yesno):
sysparam.set_bool(self.store, 'CREATE_PAYMENTS_ON_STOCK_DECREASE', True)
yesno.return_value = False
branch = api.get_current_branch(self.store)
storable = self.create_storable(branch=branch, stock=1)
sellable = storable.product.sellable
cost_center = self.create_cost_center()
wizard = StockDecreaseWizard(self.store)
entry = self.store.find(CostCenterEntry,
cost_center=wizard.model.cost_center)
self.assertEqual(len(list(entry)), 0)
step = wizard.get_current_step()
step.reason.update('test')
step.cost_center.select(cost_center)
self.check_wizard(wizard, 'stock-decrease-with-cost-center')
self.click(wizard.next_button)
step = wizard.get_current_step()
step.barcode.set_text(sellable.barcode)
step.sellable_selected(sellable)
step.quantity.update(1)
self.click(step.add_sellable_button)
with mock.patch.object(self.store, 'commit'):
self.click(wizard.next_button)
self.assertEqual(wizard.model.cost_center, cost_center)
entry = self.store.find(CostCenterEntry,
cost_center=wizard.model.cost_center)
self.assertEqual(len(list(entry)), 1)
def test_create(self):
# Allow creating purchases in the past.
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
with self.sysparam(MANDATORY_CHECK_NUMBER=True):
self.wizard = PurchaseWizard(self.store)
purchase_branch = self.create_branch()
purchase_order = PurchaseOrder(branch=purchase_branch,
station=self.current_station,
store=self.store)
sellable = self.create_sellable()
purchase_order.add_item(sellable=sellable)
self.wizard.model.identifier = 12345
self.wizard.model.open_date = localdate(2010, 1, 3).date()
self._check_start_step('wizard-purchase-start-step')
self._check_item_step('wizard-purchase-item-step')
payment_step = self.wizard.get_current_step()
payment_step.slave.bank_first_check_number.set_text('12')
self._check_payment_step('wizard-purchase-payment-step')
purchase = self.wizard.model
models = [purchase]
models.extend(purchase.get_items())
models.extend(purchase.payments)
models.append(purchase.group)
self.check_wizard(self.wizard,
'wizard-purchase-finish-step',
models=models)
self.click(self.wizard.next_button)
def test_sales_person_report(self):
sysparam.set_bool(self.store, "SALE_PAY_COMMISSION_WHEN_CONFIRMED", True)
salesperson = self.create_sales_person()
product = self.create_product(price=100)
sellable = product.sellable
sale = self.create_sale()
sale.salesperson = salesperson
sale.add_sellable(sellable, quantity=1)
self.create_storable(product, get_current_branch(self.store), stock=100)
CommissionSource(sellable=sellable, direct_value=Decimal(10), installments_value=1, store=self.store)
sale.order()
method = PaymentMethod.get_by_name(self.store, u"money")
method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, sale.get_sale_subtotal())
sale.confirm()
sale.group.pay()
salesperson = salesperson
commissions = list(self.store.find(CommissionView))
commissions[0].identifier = 1
commissions[1].identifier = 139
self._diff_expected(SalesPersonReport, "sales-person-report", commissions, salesperson)
# Also test when there is no salesperson selected
self._diff_expected(SalesPersonReport, "sales-person-report-without-salesperson", commissions, None)
def _check_param_online_services(self):
from stoqlib.database.runtime import new_store
from stoqlib.lib.parameters import sysparam
from gi.repository import Gtk
if sysparam.get_bool('ONLINE_SERVICES') is None:
from kiwi.ui.dialogs import HIGAlertDialog
# FIXME: All of this is to avoid having to set markup as the default
# in kiwi/ui/dialogs:HIGAlertDialog.set_details, after 1.0
# this can be simplified when we fix so that all descriptions
# sent to these dialogs are properly escaped
dialog = HIGAlertDialog(
parent=None,
flags=Gtk.DialogFlags.MODAL,
type=Gtk.MessageType.WARNING)
dialog.add_button(_("Not right now"), Gtk.ResponseType.NO)
dialog.add_button(_("Enable online services"), Gtk.ResponseType.YES)
dialog.set_primary(_('Do you want to enable Stoq online services?'))
dialog.set_details(PRIVACY_STRING, use_markup=True)
dialog.set_default_response(Gtk.ResponseType.YES)
response = dialog.run()
dialog.destroy()
store = new_store()
sysparam.set_bool(store, 'ONLINE_SERVICES', response == Gtk.ResponseType.YES)
store.commit()
store.close()
def _payComissionWhenConfirmed(self):
sysparam.set_bool(
self.store,
"SALE_PAY_COMMISSION_WHEN_CONFIRMED",
True)
self.failUnless(
sysparam.get_bool('SALE_PAY_COMMISSION_WHEN_CONFIRMED'))
def test_create(self):
# Allow creating purchases in the past.
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
self.wizard = PurchaseWizard(self.store)
purchase_branch = self.create_branch()
purchase_order = PurchaseOrder(branch=purchase_branch)
sellable = self.create_sellable()
purchase_order.add_item(sellable=sellable)
self.wizard.model.identifier = 12345
self.wizard.model.open_date = localdate(2010, 1, 3).date()
self._check_start_step('wizard-purchase-start-step')
self._check_item_step('wizard-purchase-item-step')
self._check_payment_step('wizard-purchase-payment-step')
purchase = self.wizard.model
models = [purchase]
models.extend(purchase.get_items())
models.extend(purchase.payments)
models.append(purchase.group)
self.check_wizard(self.wizard, 'wizard-purchase-finish-step',
models=models)
self.click(self.wizard.next_button)
def test_wizard_create_payment(self, yesno):
yesno.return_value = False
sysparam.set_bool(self.store, 'CREATE_PAYMENTS_ON_STOCK_DECREASE', True)
till = self.create_till()
till.open_till()
branch = api.get_current_branch(self.store)
storable = self.create_storable(branch=branch, stock=1)
sellable = storable.product.sellable
wizard = StockDecreaseWizard(self.store)
step = wizard.get_current_step()
self.assertTrue(step.create_payments.get_visible())
step.create_payments.update(True)
step.reason.update('reason')
self.check_wizard(wizard, 'start-stock-decrease-step-create-payments')
self.assertSensitive(wizard, ['next_button'])
self.click(wizard.next_button)
step = wizard.get_current_step()
step.barcode.set_text(sellable.barcode)
step.sellable_selected(sellable)
step.quantity.update(1)
self.click(step.add_sellable_button)
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertTrue(isinstance(step, PaymentMethodStep))
def sysparam(self, **kwargs):
"""
Updates a set of system parameters within a context.
The values will be reverted when leaving the scope.
kwargs contains a dictionary of parameter name->value
"""
from stoqlib.lib.parameters import sysparam
old_values = {}
for param, value in kwargs.items():
if type(value) is bool:
old_values[param] = sysparam.get_bool(param)
sysparam.set_bool(self.store, param, value)
elif isinstance(value, Domain) or value is None:
old_values[param] = sysparam.get_object(self.store, param)
sysparam.set_object(self.store, param, value)
else:
raise NotImplementedError(type(value))
try:
yield
finally:
for param, value in old_values.items():
if type(value) is bool:
sysparam.set_bool(self.store, param, value)
elif isinstance(value, Domain) or value is None:
sysparam.set_object(self.store, param, value)
else:
raise NotImplementedError(type(value))
def _payComissionWhenConfirmed(self):
sysparam.set_bool(
self.store,
"SALE_PAY_COMMISSION_WHEN_CONFIRMED",
True)
self.assertTrue(
sysparam.get_bool('SALE_PAY_COMMISSION_WHEN_CONFIRMED'))
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 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_create(self):
sysparam.set_bool(self.store, 'MANDATORY_CHECK_NUMBER', True)
wizard = PurchaseWizard(self.store)
method = PaymentMethod.get_by_name(self.store, u'check')
order = self.create_purchase_order()
order.identifier = 12345
slave = CheckMethodSlave(wizard, None, self.store, order, method,
Decimal(200))
self.check_slave(slave, 'slave-check-method')
def test_check_payment_mandatory_check_number(self):
sysparam.set_bool(self.store, 'MANDATORY_CHECK_NUMBER', True)
wizard = PurchaseWizard(self.store)
method = PaymentMethod.get_by_name(self.store, u'check')
order = self.create_purchase_order()
order.identifier = 123456
CheckMethodSlave(wizard, None, self.store, order, method, Decimal(200))
self.assertNotSensitive(wizard, ['next_button'])
def test_installments(self):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
wizard = PurchaseWizard(self.store)
method = PaymentMethod.get_by_name(self.store, u'bill')
order = self.create_purchase_order()
order.identifier = 12345
slave = BillMethodSlave(wizard, None, self.store, order, method,
Decimal(200), localdate(2012, 1, 1).date())
self.check_slave(slave, 'slave-bill-method-1-installments')
slave.installments_number.update(2)
self.check_slave(slave, 'slave-bill-method-2-installments')
def test_outdated(self):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', False)
wizard = PurchaseWizard(self.store)
method = PaymentMethod.get_by_name(self.store, u'bill')
order = self.create_purchase_order()
today = localtoday().date()
slave = BillMethodSlave(wizard, None, self.store, order, method,
Decimal(200), today)
self.assertValid(slave, ['first_duedate'])
slave.first_duedate.update(datetime.date(2012, 01, 01))
self.assertInvalid(slave, ['first_duedate'])
def test_installments(self):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
wizard = PurchaseWizard(self.store)
method = PaymentMethod.get_by_name(self.store, u'bill')
order = self.create_purchase_order()
order.identifier = 12345
slave = BillMethodSlave(wizard, None, self.store, order, method,
Decimal(200), localdate(2012, 01, 01).date())
self.check_slave(slave, 'slave-bill-method-1-installments')
slave.installments_number.update(2)
self.check_slave(slave, 'slave-bill-method-2-installments')
def test_outdated(self):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', False)
wizard = PurchaseWizard(self.store)
method = PaymentMethod.get_by_name(self.store, u'bill')
order = self.create_purchase_order()
today = localtoday().date()
slave = BillMethodSlave(wizard, None, self.store, order, method,
Decimal(200), today)
self.assertValid(slave, ['first_duedate'])
slave.first_duedate.update(datetime.date(2012, 1, 1))
self.assertInvalid(slave, ['first_duedate'])
def test_create(self, delete, commit):
# Allow creating purchases in the past.
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
self.wizard = QuotePurchaseWizard(self.store)
self.wizard.model.branch = self.create_branch()
self.wizard.model.identifier = 12345
self.wizard.model.open_date = localdate(2010, 1, 3).date()
self._check_start_step('wizard-purchasequote-start-step')
self._check_item_step('wizard-purchasequote-item-step')
supplier_step = self.wizard.get_current_step()
supplier_step.quoting_list.select(supplier_step.quoting_list[0])
patch = 'stoqlib.gui.wizards.purchasequotewizard.run_dialog'
with mock.patch(patch) as run_dialog:
self.click(supplier_step.missing_products_button)
run_dialog.assert_called_once_with(SimpleListDialog,
self.wizard,
supplier_step.product_columns,
set([]),
title='Missing Products')
sellable = supplier_step.model.get_items()[0].sellable
with mock.patch(patch) as run_dialog:
self.click(supplier_step.view_products_button)
run_dialog.assert_called_once_with(
SimpleListDialog,
self.wizard,
supplier_step.product_columns, [sellable],
title='Products supplied by Supplier')
patch = 'stoqlib.gui.wizards.purchasequotewizard.print_report'
with mock.patch(patch) as print_report:
self.click(supplier_step.print_button)
print_report.assert_called_once_with(PurchaseQuoteReport,
self.wizard.model)
self._check_supplier_step('wizard-purchasequote-supplier-step')
# FIXME: How many times?
self.assertEquals(commit.call_count, 1)
purchase = self.wizard.model
models = [purchase]
models.extend(purchase.get_items())
self.check_wizard(self.wizard,
'wizard-purchasequote-finish-step',
models=models)
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')
def test_step_payment_method_check(self):
sysparam.set_bool(self.store, 'MANDATORY_CHECK_NUMBER', False)
self._create_wizard()
self._select_method('check')
self._go_to_next()
# populate check and bank data
self.bank_id = 123
self.bank_branch = 456
self.bank_account = 789
# Finish the checkout
with mock.patch.object(self.store, 'commit'):
self._go_to_next()
self.assertEquals(self.sale.payments[0].method.method_name, u'check')
self._check_wizard('wizard-sale-step-payment-method-check')
def test_create(self, yesno, run_dialog):
# Allow creating purchases in the past.
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
quotation = self.create_quotation()
quotation.identifier = 12345
quotation.group.identifier = 67890
def _purchase_clone():
self.purchase_clone = Domain.clone(self.purchase)
return self.purchase_clone
purchase = self.purchase = quotation.purchase
purchase.clone = _purchase_clone
purchase.open_date = localdate(2012, 1, 1).date()
self.create_purchase_order_item(purchase)
self.wizard = ReceiveQuoteWizard(self.store)
start_step = self.wizard.get_current_step()
start_step.search.refresh()
start_step.search.results.select(start_step.search.results[0])
self._check_start_step('wizard-receivequote-start-step')
self._check_start_step('wizard-receivequote-item-step')
item_step = self.wizard.get_current_step()
new_store = 'stoqlib.gui.wizards.purchasequotewizard.api.new_store'
with mock.patch(new_store) as new_store:
with mock.patch.object(self.store, 'commit'):
with mock.patch.object(self.store, 'close'):
new_store.return_value = self.store
self.click(item_step.create_order_button)
run_dialog.assert_called_once_with(PurchaseWizard,
self.wizard, self.store,
self.purchase_clone)
yesno.assert_called_once_with(
'Should we close the quotes used to compose the '
'purchase order ?', gtk.RESPONSE_NO, 'Close quotes',
"Don't close")
self.click(self.wizard.next_button)
models = [quotation, quotation.group, purchase]
models.extend(purchase.get_items())
self.check_wizard(self.wizard,
'wizard-receivequote-finish-step',
models=models)
def test_create(self, yesno, run_dialog):
# Allow creating purchases in the past.
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
quotation = self.create_quotation()
quotation.identifier = 12345
quotation.group.identifier = 67890
def _purchase_clone():
self.purchase_clone = Domain.clone(self.purchase)
return self.purchase_clone
purchase = self.purchase = quotation.purchase
purchase.clone = _purchase_clone
purchase.open_date = localdate(2012, 1, 1).date()
self.create_purchase_order_item(purchase)
self.wizard = ReceiveQuoteWizard(self.store)
start_step = self.wizard.get_current_step()
start_step.search.refresh()
start_step.search.results.select(start_step.search.results[0])
self._check_start_step('wizard-receivequote-start-step')
self._check_start_step('wizard-receivequote-item-step')
item_step = self.wizard.get_current_step()
new_store = 'stoqlib.gui.wizards.purchasequotewizard.api.new_store'
with mock.patch(new_store) as new_store:
with mock.patch.object(self.store, 'commit'):
with mock.patch.object(self.store, 'close'):
new_store.return_value = self.store
self.click(item_step.create_order_button)
run_dialog.assert_called_once_with(PurchaseWizard,
self.wizard,
self.store,
self.purchase_clone)
yesno.assert_called_once_with(
'Should we close the quotes used to compose the '
'purchase order ?', gtk.RESPONSE_NO, 'Close quotes',
"Don't close")
self.click(self.wizard.next_button)
models = [quotation, quotation.group, purchase]
models.extend(purchase.get_items())
self.check_wizard(self.wizard, 'wizard-receivequote-finish-step',
models=models)
def test_step_payment_method_check(self):
sysparam.set_bool(self.store, 'MANDATORY_CHECK_NUMBER', False)
self._create_wizard()
self._select_method('check')
self._go_to_next()
# populate check and bank data
self.bank_id = 123
self.bank_branch = 456
self.bank_account = 789
# Finish the checkout
with mock.patch.object(self.store, 'commit'):
self._go_to_next()
self.assertEqual(self.sale.payments[0].method.method_name, u'check')
self._check_wizard('wizard-sale-step-payment-method-check')
def test_create(self, delete, commit):
# Allow creating purchases in the past.
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
self.wizard = QuotePurchaseWizard(self.store)
self.wizard.model.branch = self.create_branch()
self.wizard.model.identifier = 12345
self.wizard.model.open_date = localdate(2010, 1, 3).date()
self._check_start_step('wizard-purchasequote-start-step')
self._check_item_step('wizard-purchasequote-item-step')
supplier_step = self.wizard.get_current_step()
supplier_step.quoting_list.select(supplier_step.quoting_list[0])
patch = 'stoqlib.gui.wizards.purchasequotewizard.run_dialog'
with mock.patch(patch) as run_dialog:
self.click(supplier_step.missing_products_button)
run_dialog.assert_called_once_with(SimpleListDialog, self.wizard,
supplier_step.product_columns,
set([]), title='Missing Products')
sellable = supplier_step.model.get_items()[0].sellable
with mock.patch(patch) as run_dialog:
self.click(supplier_step.view_products_button)
run_dialog.assert_called_once_with(
SimpleListDialog, self.wizard, supplier_step.product_columns,
[sellable], title='Products supplied by Supplier')
patch = 'stoqlib.gui.wizards.purchasequotewizard.print_report'
with mock.patch(patch) as print_report:
self.click(supplier_step.print_button)
print_report.assert_called_once_with(
PurchaseQuoteReport, self.wizard.model)
self._check_supplier_step('wizard-purchasequote-supplier-step')
# FIXME: How many times?
self.assertEquals(commit.call_count, 1)
purchase = self.wizard.model
models = [purchase]
models.extend(purchase.get_items())
self.check_wizard(self.wizard, 'wizard-purchasequote-finish-step',
models=models)
def sysparam(self, **kwargs):
"""
Updates a set of system parameters within a context.
The values will be reverted when leaving the scope.
kwargs contains a dictionary of parameter name->value
"""
from stoqlib.lib.parameters import sysparam
old_values = {}
for param, value in kwargs.items():
if isinstance(value, bool):
old_values[param] = sysparam.get_bool(param)
sysparam.set_bool(self.store, param, value)
elif isinstance(value, int):
old_values[param] = sysparam.get_int(param)
sysparam.set_int(self.store, param, value)
elif isinstance(value, Domain) or value is None:
old_values[param] = sysparam.get_object(self.store, param)
sysparam.set_object(self.store, param, value)
elif isinstance(value, str):
old_values[param] = sysparam.get_string(param)
sysparam.set_string(self.store, param, value)
elif isinstance(value, Decimal):
old_values[param] = sysparam.get_decimal(param)
sysparam.set_decimal(self.store, param, value)
else:
raise NotImplementedError(type(value))
try:
yield
finally:
for param, value in old_values.items():
if isinstance(value, bool):
sysparam.set_bool(self.store, param, value)
elif isinstance(value, int):
sysparam.set_int(self.store, param, value)
elif isinstance(value, Domain) or value is None:
sysparam.set_object(self.store, param, value)
elif isinstance(value, str):
sysparam.set_string(self.store, param, value)
elif isinstance(value, Decimal):
sysparam.set_decimal(self.store, param, value)
else:
raise NotImplementedError(type(value))
def test_sale_selection_step_unknown_sale(self):
sysparam.set_bool(self.store, 'ALLOW_TRADE_NOT_REGISTERED_SALES', True)
wizard = SaleTradeWizard(self.store)
step = wizard.get_current_step()
results = step.slave.results
# Since ALLOW_TRADE_NOT_REGISTERED_SALES is True,
# the user should be able to check this
self.assertVisible(step, ['unknown_sale_check'])
# next_button should only be sensitive if a sale is selected
self.assertNotSensitive(wizard, ['next_button'])
results.select(results[0])
self.assertSensitive(wizard, ['next_button'])
results.unselect_all()
self.assertNotSensitive(wizard, ['next_button'])
self.click(step.unknown_sale_check)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'wizard-trade-sale-selection-step-unknown-sale')
def test_work_order_editor(self):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
sale = self.create_sale()
workorder = self.create_workorder()
workorder.identifier = 1234
workorder.open_date = localdate(2012, 1, 1)
workorder.sale = sale
editor = WorkOrderEditor(store=self.store, model=workorder)
self.check_editor(editor, u'editor-work-order-optical-plugin')
# FIXME: baseditor should probably add an api for getting a list
# of buttons
print_button = editor.main_dialog.action_area.get_children()[0]
assert print_button.get_label() == Gtk.STOCK_PRINT
with mock.patch(
'plugins.optical.opticalui.print_report') as print_report_:
self.click(print_button)
print_report_.assert_called_once_with(
OpticalWorkOrderReceiptReport, [editor.model])
def test_sale_selection_step_unknown_sale(self):
sysparam.set_bool(self.store, 'ALLOW_TRADE_NOT_REGISTERED_SALES', True)
wizard = SaleTradeWizard(self.store)
step = wizard.get_current_step()
results = step.slave.results
# Since ALLOW_TRADE_NOT_REGISTERED_SALES is True,
# the user should be able to check this
self.assertVisible(step, ['unknown_sale_check'])
# next_button should only be sensitive if a sale is selected
self.assertNotSensitive(wizard, ['next_button'])
results.select(results[0])
self.assertSensitive(wizard, ['next_button'])
results.unselect_all()
self.assertNotSensitive(wizard, ['next_button'])
self.click(step.unknown_sale_check)
self.assertSensitive(wizard, ['next_button'])
self.check_wizard(wizard, 'wizard-trade-sale-selection-step-unknown-sale')
def test_sales_person_report(self):
sysparam.set_bool(self.store, 'SALE_PAY_COMMISSION_WHEN_CONFIRMED',
True)
salesperson = self.create_sales_person()
product = self.create_product(price=100)
sellable = product.sellable
sale = self.create_sale()
sale.salesperson = salesperson
sale.add_sellable(sellable, quantity=1)
self.create_storable(product,
get_current_branch(self.store),
stock=100)
CommissionSource(sellable=sellable,
direct_value=Decimal(10),
installments_value=1,
store=self.store)
sale.order(self.current_user)
method = PaymentMethod.get_by_name(self.store, u'money')
method.create_payment(sale.branch, sale.station, Payment.TYPE_IN,
sale.group, sale.get_sale_subtotal())
sale.confirm(self.current_user)
sale.group.pay()
salesperson = salesperson
commissions = list(self.store.find(CommissionView))
commissions[0].identifier = 1
commissions[1].identifier = 139
self._diff_expected(SalesPersonReport, 'sales-person-report',
commissions, salesperson)
# Also test when there is no salesperson selected
self._diff_expected(SalesPersonReport,
'sales-person-report-without-salesperson',
commissions, None)
def test_work_order_editor(self):
sysparam.set_bool(self.store,
'ALLOW_OUTDATED_OPERATIONS',
True)
sale = self.create_sale()
workorder = self.create_workorder()
workorder.identifier = 1234
workorder.open_date = localdate(2012, 1, 1)
workorder.sale = sale
editor = WorkOrderEditor(store=self.store, model=workorder)
self.check_editor(editor, u'editor-work-order-optical-plugin')
# FIXME: baseditor should probably add an api for getting a list
# of buttons
print_button = editor.main_dialog.action_area.get_children()[0]
assert print_button.get_label() == gtk.STOCK_PRINT
with mock.patch('plugins.optical.opticalui.print_report') as print_report_:
self.click(print_button)
print_report_.assert_called_once_with(
OpticalWorkOrderReceiptReport, [editor.model])
def test_confirm(self, run_person_role_dialog, run_dialog, yesno):
client = self.create_client()
self.create_address(person=client.person)
run_person_role_dialog.return_value = client
yesno.return_value = False
sellable = self.create_sellable()
sellable.barcode = u'12345678'
wizard = SaleQuoteWizard(self.store)
step = wizard.get_current_step()
self.click(step.create_client)
self.assertEquals(run_person_role_dialog.call_count, 1)
args, kwargs = run_person_role_dialog.call_args
editor, parent, store, model = args
self.assertEquals(editor, ClientEditor)
self.assertEquals(parent, wizard)
self.assertTrue(store is not None)
self.assertTrue(model is None)
self.click(step.client_details)
self.assertEquals(run_dialog.call_count, 1)
args, kwargs = run_dialog.call_args
dialog, parent, store, model = args
self.assertEquals(dialog, ClientDetailsDialog)
self.assertEquals(parent, wizard)
self.assertTrue(store is not None)
self.assertEquals(model, client)
self.click(step.notes_button)
self.assertEquals(run_dialog.call_count, 2)
args, kwargs = run_dialog.call_args
editor, parent, store, model, notes = args
self.assertEquals(editor, NoteEditor)
self.assertEquals(parent, wizard)
self.assertTrue(store is not None)
self.assertEquals(set(wizard.model.comments), set([model]))
self.assertEquals(notes, 'comment')
self.assertEquals(kwargs['title'], _("Sale observations"))
self.check_wizard(wizard, 'wizard-sale-quote-start-sale-quote-step')
self.click(wizard.next_button)
step = wizard.get_current_step()
self.assertNotSensitive(wizard, ['next_button'])
step.barcode.set_text(sellable.barcode)
step.sellable_selected(sellable)
step.quantity.update(2)
# Make sure that we cannot add an item with a value greater than the allowed.
sysparam.set_bool(self.store, 'ALLOW_HIGHER_SALE_PRICE', False)
step.cost.update(11)
self.assertNotSensitive(step, ['add_sellable_button'])
step.cost.update(10)
self.assertSensitive(step, ['add_sellable_button'])
self.click(step.add_sellable_button)
self.assertSensitive(wizard, ['next_button'])
sale = wizard.model
self.check_wizard(wizard, 'wizard-sale-quote-sale-quote-item-step',
[sale, client] + list(sale.get_items()) + [sellable])
module = 'stoqlib.gui.events.SaleQuoteWizardFinishEvent.emit'
with mock.patch(module) as emit:
with mock.patch.object(self.store, 'commit'):
self.click(wizard.next_button)
self.assertEquals(emit.call_count, 1)
args, kwargs = emit.call_args
self.assertTrue(isinstance(args[0], Sale))
self.assertEqual(wizard.model.payments.count(), 0)
yesno.assert_called_once_with(_('Would you like to print the quote '
'details now?'), gtk.RESPONSE_YES,
_("Print quote details"), _("Don't print"))
def test_create(self, localnow):
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', False)
localnow.return_value = localdatetime(2013, 1, 1)
# Create those before initializating the editor so they get prefilled
category = WorkOrderCategory(store=self.store,
name=u'Categoty XXX')
client = self.create_client()
with self.sysparam(DEFECT_DETECTED_TEMPLATE=u"XXX\nYYY"):
editor = WorkOrderEditor(self.store)
self.assertEqual(editor.model.defect_detected, u"XXX\nYYY")
editor.model.identifier = 654
self.assertEqual(editor.supplier_order.read(), u"")
editor.supplier_order.update(u"A1234")
editor.proxy.update('identifier')
editor.proxy.update('supplier_order')
self.assertEqual(editor.supplier_order.read(), u"A1234")
opening_slave = editor.opening_slave
execution_slave = editor.execution_slave
item_slave = execution_slave.sellable_item_slave
quote_slave = editor.quote_slave
self.assertSensitive(editor, ['client'])
self.assertSensitive(editor, ['supplier_order'])
self.assertNotSensitive(editor, ['category_edit'])
# Check creation state
self.assertEqual(editor.model.status, WorkOrder.STATUS_OPENED)
self.check_editor(editor, 'editor-workorder-create')
editor.description.update(u"Test equipment")
editor.category.update(category)
self.assertNotSensitive(editor, ['toggle_status_btn'])
editor.client_gadget.set_value(client)
self.assertSensitive(editor, ['toggle_status_btn'])
opening_slave.defect_reported.update(u"Defect reported")
# Check initial state
self.assertEqual(editor.model.status, WorkOrder.STATUS_OPENED)
self.check_editor(editor, 'editor-workorder-create-initial')
quote_slave.defect_detected.update(u"Defect detected")
quote_slave.estimated_hours.update(10)
quote_slave.estimated_hours.update(100)
quote_slave.estimated_start.update(localdatetime(2013, 1, 1))
quote_slave.estimated_finish.update(localdatetime(2013, 1, 2))
self.assertInvalid(quote_slave, ['estimated_start'])
sysparam.set_bool(self.store, 'ALLOW_OUTDATED_OPERATIONS', True)
quote_slave.estimated_start.validate(force=True)
self.assertValid(quote_slave, ['estimated_start'])
# Clicking the first time will approve the order (put it on waiting state)
self.click(editor.toggle_status_btn)
self.assertEqual(editor.model.status, WorkOrder.STATUS_WORK_WAITING)
# The second time will start thr work
self.click(editor.toggle_status_btn)
self.assertEqual(editor.model.status, WorkOrder.STATUS_WORK_IN_PROGRESS)
_adjust_history_date(editor.model)
# FIXME: For some reason, history_slave.update_items is not really
# updating the list (it calls add_list that should do that) and because
# of that the items' dates are not updated when they should
# (update_items will call add_list that should call clear before).
# Calling clear here fixes the problem, but it should not be necessary.
# This is probably a kiwi issue
editor.history_slave.details_list.clear()
editor.history_slave.update_items()
self.check_editor(editor, 'editor-workorder-create-approved')
product_sellable = self.create_product(stock=100).sellable
product_sellable.barcode = u'9988776655'
service_sellable = self.create_service().sellable
service_sellable.barcode = u'5566778899'
item_slave.barcode.set_text(product_sellable.barcode)
item_slave.barcode.activate()
item_slave.cost.update(50)
item_slave.quantity.update(101)
self.assertNotSensitive(item_slave, ['add_sellable_button'])
item_slave.quantity.update(99)
self.assertSensitive(item_slave, ['add_sellable_button'])
self.click(item_slave.add_sellable_button)
item_slave.barcode.set_text(service_sellable.barcode)
item_slave.barcode.activate()
item_slave.cost.update(100)
item_slave.quantity.update(2)
self.click(item_slave.add_sellable_button)
# Check work in progress state
self.check_editor(editor, 'editor-workorder-create-in-progress')
self.click(editor.main_dialog.ok_button)
storable = product_sellable.product_storable
# This should be 1 since we created it with 100 and used 99 in the order
self.assertEqual(
storable.get_balance_for_branch(editor.model.branch), 1)
