def test(): # pragma no cover
from nose.exc import SkipTest
try:
import gi
gi # workaround pyflakes
except ImportError:
raise SkipTest("can't run test without pygobject installed")
from kiwi.ui.objectlist import ObjectList
from stoq.api import api as stoq_api
from stoqlib.api import api
from stoq.gui.sales import SalesApp
from stoqlib.domain.sale import SaleView
stoq_api.prepare_test()
store = api.new_store()
class Foo(SalesApp):
def __init__(self):
pass
a = Foo()
ol = ObjectList(a.get_columns())
data = store.find(SaleView)
r = SalesReport('teste.pdf', ol, list(data))
r.save_html('teste.html')
r.save()
def test_dialog(): # pragma nocover
from stoq.lib.gui.base.dialogs import run_dialog
ec = stoq_api.prepare_test()
client = ec.store.find(Client).any()
run_dialog(OpticalPatientDetails, None, ec.store, client)
ec.store.commit()
def test_price_editor(): # pragma nocover
from decimal import Decimal
ec = stoq_api.prepare_test()
sellable = ec.create_sellable()
sellable.cost = Decimal('15.55')
sellable.price = Decimal('21.50')
run_dialog(SellablePriceEditor,
parent=None, store=ec.store, model=sellable)
def test(): # pragma nocover
from stoqlib.domain.sale import Sale
from stoq.api import api as stoq_api
import sys
creator = stoq_api.prepare_test()
sale = creator.store.find(Sale, id=int(sys.argv[-1])).one()
r = BookletReport('teste.pdf', sale.payments)
r.save_html('teste.html')
r.save()
def test_grid_editor(): # pragma nocover
from stoq.lib.gui.base.dialogs import run_dialog
ec = stoq_api.prepare_test()
group = ec.store.find(GridGroup).any()
attribute = ec.create_grid_attribute(attribute_group=group)
attribute.group = None
run_dialog(GridAttributeEditor,
parent=None, store=ec.store, model=attribute)
print(attribute.group)
def test(): # pragma nocover
creator = stoq_api.prepare_test()
retval = run_dialog(AccountEditor,
None,
creator.store,
None,
parent_account=None,
visual_mode=True)
creator.store.confirm(retval)
def test_editor(editor): # pragma nocover
from stoq.lib.gui.base.dialogs import run_dialog
ec = stoq_api.prepare_test()
model = ec.store.find(editor.model_type).any()
if not model:
client = ec.store.find(Client).any()
run_dialog(editor, None, ec.store, client)
else:
run_dialog(editor, None, ec.store, model.client, model)
ec.store.commit()
def test(): # pragma nocover
creator = stoq_api.prepare_test()
sale_item = creator.create_sale_item()
retval = run_dialog(ConfirmSaleWizard, None, creator.store, sale_item.sale)
creator.store.confirm(retval)
def test_employee_role(): # pragma nocover
creator = stoq_api.prepare_test()
role = creator.create_employee_role()
run_dialog(EmployeeRoleEditor, parent=None, store=creator.store,
model=role)
def test_client(): # pragma nocover
from stoq.lib.gui.wizards.personwizard import run_person_role_dialog
creator = stoq_api.prepare_test()
retval = run_person_role_dialog(ClientEditor, None, creator.store, None)
creator.store.confirm(retval)
def test(): # pragma: no cover
from stoq.lib.gui.base.dialogs import run_dialog
ec = stoq_api.prepare_test()
model = ec.store.find(CostCenter).any()
run_dialog(CostCenterDialog, None, ec.store, model)
def test(): # pragma nocover
creator = stoq_api.prepare_test()
account = creator.create_account()
retval = run_dialog(AccountTransactionEditor, None, creator.trans, None,
account)
api.creator.trans.confirm(retval)
drawer_address=self._get_person_address(drawer_person),
due_date=self.loan.expire_date,
value=self.loan.get_total_amount(),
emission_city=emission_location.city,
emission_date=datetime.date.today(),
)
return dict(subtitle=_("Loan number: %s") % order_identifier,
loan=self.loan,
print_promissory_note=print_promissory_note,
promissory_data=promissory_data,
notice=api.sysparam.get_string('LOAN_NOTICE'))
def adjust_for_test(self):
# today is mocked on test
date = datetime.date.today()
self.loan.expire_date = date
self.loan.open_date = date
self.loan.identifier = 666
self.logo_data = 'logo.png'
if __name__ == '__main__': # pragma nocover
from stoqlib.domain.loan import Loan
import sys
creator = stoq_api.prepare_test()
loan_ = creator.trans.find(Loan, id=int(sys.argv[-1])).one()
r = LoanReceipt('test.pdf', loan_)
r.save_html('test.html')
r.save()
def test(): # pragma nocover
creator = stoq_api.prepare_test()
method = PaymentMethod.get_by_name(creator.store, u'card')
retval = run_dialog(CardPaymentMethodEditor, None, creator.store, method)
creator.store.confirm(retval)
# Payments
payment = self.add_payments(order, date=date)[0]
payment.identifier = 999
payment.group.payer = supplier.person
payment.status = Payment.STATUS_PAID
dialog = SupplierDetailsDialog(self.store, supplier)
self.check_editor(dialog, 'dialog-supplier-details')
@mock.patch('stoq.lib.gui.dialogs.supplierdetails.run_person_role_dialog')
def test_further_details(self, run_dialog):
supplier = self.create_supplier()
dialog = SupplierDetailsDialog(self.store, supplier)
self.click(dialog.further_details_button)
args, kwargs = run_dialog.call_args
editor, d, store, model = args
self.assertEqual(editor, SupplierEditor)
self.assertEqual(d, dialog)
self.assertEqual(model, dialog.model)
self.assertTrue(isinstance(store, StoqlibStore))
self.assertEqual(kwargs.pop('visual_mode'), True)
self.assertEqual(kwargs, {})
if __name__ == '__main__':
from stoq.api import api as stoq_api
c = stoq_api.prepare_test()
unittest.main()
def test(): # pragma: no cover
from stoq.lib.gui.base.dialogs import run_dialog
ec = stoq_api.prepare_test()
run_dialog(ProductSearch, None, ec.store)
def test(): # pragma: no cover
from stoq.api import api as stoq_api
ec = stoq_api.prepare_test()
run_dialog(CostCenterSearch, None, ec.store)
def test_sellable_tax_constant(): # pragma nocover
ec = stoq_api.prepare_test()
tax_constant = api.sysparam.get_object(ec.store, 'DEFAULT_PRODUCT_TAX_CONSTANT')
run_dialog(SellableTaxConstantEditor,
parent=None, store=ec.store, model=tax_constant)
print(tax_constant)
def test(): # pragma: no cover
ec = stoq_api.prepare_test()
person = run_dialog(BranchDialog, None, ec.store)
print('RETVAL', person)
def test(): # pragma nocover
creator = stoq_api.prepare_test()
retval = run_dialog(InPaymentEditor, None, creator.store, None)
creator.store.confirm(retval)
def test_product(): # pragma nocover
ec = stoq_api.prepare_test()
product = ec.create_product()
run_dialog(ProductEditor, parent=None, store=ec.store, model=product)
def test(): # pragma nocover
creator = stoq_api.prepare_test()
retval = run_dialog(PurchaseWizard, None, creator.store)
creator.store.confirm(retval)
def test(): # pragma nocover
creator = stoq_api.prepare_test()
run_dialog(CloseLoanWizard, None, creator.store, create_sale=True)
creator.store.rollback()
