def test_encode_wrong_order_id(self):
# python test_edit_timetracks.py TestEditTimetracks.test_encode_wrong_order_id
app = self.app
widget = self.widget
today = date.today()
widget.set_employee_and_date(self.employee.employee_id, today)
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_F5, Qt.ShiftModifier) # modifier, delay
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_9) # modifier, delay
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_9) # modifier, delay
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_9) # modifier, delay
app.processEvents()
timer = QTimer()
timer.timeout.connect(self._click_order_inexistant_box)
timer.setSingleShot(True)
timer.start(250)
self.test_sucess = False
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
app.processEvents()
assert self.test_sucess
def test_encode_delivery_slip_without_quantity(self):
self._pg_locks("on start")
app = self.app
widget = self.widget
order = self._make_order()
order.parts[0].qty = 10
order.parts[0].sell_price = 10
self.order_dao.change_order_parts_state(
order.order_id, [order.parts[0].order_part_id],
OrderPartStateType.ready_for_production)
widget.set_data(order.order_id)
widget.show()
widget._start_edit()
app.processEvents()
self._pg_locks()
# Finish editing
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
self.prepare_to_click_dialog("quantity_missing")
# Submit form
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
assert self.dialog_test_result
assert not session().query(DeliverySlip.delivery_slip_id).all()
def test_print_preorder(self):
# python test_integration.py TestEditOrderParts.test_print_preorder
app = self.app
widget = self.widget
self._make_basic_preorder()
self._encode_imputable_operation("Description2")
self._encode_imputable_operation("Description3")
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
# We're going to have a modal dialog for the
# preorder print. So we prepare to click on it.
timer = QTimer()
timer.timeout.connect(self._fill_preorder_print_dialog)
timer.setSingleShot(True)
timer.start(250)
self.prepare_to_click_dialog("set_preorder_sent_state", 3)
widget.preorderPrint()
order = dao.order_dao.find_by_id(widget._current_order.order_id)
self.assertEqual("ZuluHeader", order.preorder_print_note)
self.assertEqual("ZuluFooter", order.preorder_print_note_footer)
def _encode_part(self, order_part_human_identifier, nb_hours=2):
widget = self.widget
app = self.app
k = [
Qt.Key_0, Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_4, Qt.Key_5,
Qt.Key_6, Qt.Key_7, Qt.Key_8, Qt.Key_9, Qt.Key_A, Qt.Key_B,
Qt.Key_C, Qt.Key_D, Qt.Key_E, Qt.Key_F, Qt.Key_G, Qt.Key_H,
Qt.Key_I, Qt.Key_J, Qt.Key_K, Qt.Key_L, Qt.Key_M, Qt.Key_N,
Qt.Key_O, Qt.Key_P, Qt.Key_Q, Qt.Key_R, Qt.Key_S, Qt.Key_T,
Qt.Key_U, Qt.Key_V, Qt.Key_W, Qt.Key_X, Qt.Key_Y, Qt.Key_Z
]
k = dict(
list(
zip([
"z{}".format(c)
for c in "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
], k)))
for digit in order_part_human_identifier:
kdigit = "z{}".format(digit)
QTest.keyEvent(QTest.Click, app.focusWidget(),
k[kdigit]) # modifier, delay
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
app.processEvents()
def test_login(self):
mainlog.debug("test_login")
d = LoginDialog(None,user_session)
d.show()
mainlog.debug("test_login : shown")
for i in range(100000):
self.app.processEvents() # Linux needs a vrey long break
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_D) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_K) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Tab) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_K) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_K) # modifier, delay
self.app.processEvents()
d.buttons.button(QDialogButtonBox.Ok).click()
self.app.processEvents()
self.assertTrue(user_session.is_active())
def test_encode_and_remove_unbillable(self):
app = self.app
widget = self.widget
self._pg_locks("before init ")
today = date.today()
widget.set_employee_and_date(self.employee.employee_id, today)
self._fix_focus(widget, widget.controller.view)
self._encode_imputable_non_billable(nb_hours = 1)
self._encode_imputable_non_billable(nb_hours = 2)
self._encode_imputable_non_billable(nb_hours = 4)
app.processEvents()
widget.buttons.button(QDialogButtonBox.Ok).click()
app.processEvents()
tts = dao.timetrack_dao.all_work_for_employee_date(self.employee.employee_id,today)
self.assertEqual(7.0, sum([tt.duration for tt in tts]))
self.assertEqual(3,len(tts))
widget.show()
widget.set_employee_and_date(self.employee.employee_id, date.today())
self._fix_focus(widget, widget.controller.view)
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_F8) # modifier, delay
app.processEvents()
widget.buttons.button(QDialogButtonBox.Ok).click()
app.processEvents()
tts = dao.timetrack_dao.all_work_for_employee_date(self.employee.employee_id,today)
self.assertEqual(6.0, sum([tt.duration for tt in tts]))
self.assertEqual(2,len(tts))
def test_edit_order(self):
app = self.app
widget = self.widget
mw = self.mw
self._make_basic_preorder()
m = widget.controller_part.view.model()
widget.controller_part.view.setCurrentIndex(m.index(0, 0))
widget.controller_part.view.setFocus(Qt.OtherFocusReason)
QTest.keyEvent(QTest.Click, widget.controller_part.view,
Qt.Key_Up) # modifier, delay
QTest.keyEvent(QTest.Click, widget.controller_part.view,
Qt.Key_F5) # modifier, delay
app.processEvents()
self._fill_order_part("Order part zero")
QTest.keyEvent(QTest.Click, app.focusWidget(),
Qt.Key_Escape) # modifier, delay
QTest.keyEvent(QTest.Click, widget.controller_part.view, Qt.Key_F5,
Qt.ShiftModifier) # modifier, delay
app.processEvents()
self._fill_order_part("Order part two")
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
def keyEvent(self, action, widget, key,
modifier=qt.Qt.NoModifier, delay=-1):
"""Sends a Qt key event.
See QTest.keyEvent for details.
"""
QTest.keyEvent(action, widget, key, modifier, delay)
self.qWait(20)
def keyEvent(self, action, widget, key,
modifier=qt.Qt.NoModifier, delay=-1):
"""Sends a Qt key event.
See QTest.keyEvent for details.
"""
QTest.keyEvent(action, widget, key, modifier, delay)
self.qWait(20)
def test_change_order_customer_cancelled(self):
customer2 = self._customer_dao.make(
"AAAA") # Name chosen so it happens first int he customer dialog
self._customer_dao.save(customer2)
app = self.app
widget = self.widget
mw = self.mw
self._make_basic_preorder()
self._encode_imputable_operation("Description2")
self._encode_imputable_operation("Description3")
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
# Make sure the test is set up correctly
preorder = self.order_dao.find_by_id_frozen(
widget._current_order.order_id)
assert preorder.customer_id == self.customer.customer_id
# We're going to have a modal dialog for the new
# customer name. So we prepare to click on it.
timer = QTimer()
timer.timeout.connect(self._cancel_dialog)
timer.setSingleShot(True)
timer.start(1000) # Had 250, my linux seems to prefer 1000
widget.change_customer() # blocks
app.processEvents()
# app.exec_() # Wait for the timer to shoot
widget.setFocus(
Qt.OtherFocusReason) # This refocus was introduced for linux
for i in range(1000):
app.processEvents() # Linux needs a break
mainlog.debug("Pressing ctrl-S on this widget : {}".format(
app.focusWidget()))
# app.exec_()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
preorder = self.order_dao.find_by_id_frozen(
widget._current_order.order_id)
assert preorder.customer_id == self.customer.customer_id
self.order_dao.delete(preorder.order_id)
self.dao.customer_dao.delete(customer2.customer_id)
def test_change_order_customer(self):
customer2 = self._customer_dao.make(
"AAAA") # Name chosen so it happens first int he customer dialog
self._customer_dao.save(customer2)
app = self.app
widget = self.widget
mw = self.mw
self._make_basic_preorder()
self._encode_imputable_operation("Description2")
self._encode_imputable_operation("Description3")
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
# Make sure the test is set up correctly
preorder = self.order_dao.find_by_id_frozen(
widget._current_order.order_id)
assert preorder.customer_id == self.customer.customer_id
# We're going to have a modal dialog for the new
# customer name. So we prepare to click on it.
timer = QTimer()
timer.timeout.connect(self._lookup)
timer.setSingleShot(True)
timer.start(1000)
widget.change_customer()
# app.exec_() # Wait for the timer to shoot
mainlog.debug("test_change_order_customer" * 10)
mainlog.debug(app.focusWidget())
widget.setFocus(
Qt.OtherFocusReason) # This refocus was introduced for linux
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
mainlog.debug("test_change_order_customer")
preorder = self.order_dao.find_by_id_frozen(
widget._current_order.order_id)
assert preorder.customer_id == customer2.customer_id
mainlog.debug("test_change_order_customer")
self.order_dao.delete(preorder.order_id)
self.dao.customer_dao.delete(customer2.customer_id)
def test_edit_order_add_rename_documents(self):
app = self.app
widget = self.widget
mw = self.mw
widget.edit_new_order(self.customer_id)
widget.controller_part.view.setFocus(Qt.OtherFocusReason)
self._fill_order_part("Order part one")
# Put the cursor back on the first line so the next document drop is tied to it.
QTest.keyEvent(QTest.Click, widget.controller_part.view, Qt.Key_Up)
app.processEvents()
# app.exec_()
# Drop a document
tmp_file, tmp_path = self._make_tmp_file()
mime_data = QMimeData()
url = "file:///{}".format(os.path.abspath(tmp_path).replace('\\', '/'))
mainlog.debug("Dropping at {}".format(QUrl(url).toString()))
mime_data.setUrls([QUrl(url)])
make_document_drop(widget.documents_widget.view, QPoint(10, 10),
mime_data)
self._clear_tmp_file(tmp_file, tmp_path)
# Now it has been dropped, rename it
# (this tests things like non-delayed create, delayed rename)
model = widget.documents_widget.model
fn_ndx = model.prototype.index_of("filename")
ndx = model.index(0, fn_ndx)
model.setData(ndx, "New name", Qt.UserRole)
#app.exec_()
# Now save the whole order
widget.setFocus()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
order = dao.order_dao.find_by_id(widget._current_order.order_id)
#app.exec_()
self.assertEqual(1, len(order.parts[0].documents),
"One document was added on the first part")
documents = [d for d in order.parts[0].documents] # Set to array
self.assertEqual("New name", documents[0].filename,
"Rename should've been applied")
def test_happy(self):
order = self._make_order()
dao.order_dao.save(order)
session().commit()
order_id = order.order_id
session().close()
b = self.widget.buttons.button(QDialogButtonBox.Ok)
self.widget.set_preorder( order_id)
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Enter)
self.app.processEvents()
def _scan(self,barcode):
""" Simulate a real barcode scan.
"""
bc = str(barcode) + str(BarCode(barcode)._checksum())
mainlog.debug("Sending a scan : {}".format(bc))
QTest.keyClicks(self.app.focusWidget(), bc) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Enter) # modifier, delay
self.app.processEvents()
def test_create_order_and_report_on_operation(self):
app = self.app
widget = self.widget
mw = self.mw
self._make_basic_preorder()
# add some more operation
self._encode_not_imputable_operation()
widget._set_state(OrderStatusType.order_ready_for_production)
self.prepare_to_click_dialog("confirm_estimate_sent")
# Save
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
order = dao.order_dao.find_by_id(widget._current_order.order_id)
mainlog.debug(order)
mainlog.debug(order.parts[0])
mainlog.debug(order.parts[0].production_file[0])
operation = order.parts[0].production_file[0].operations[0]
employee_id = dao.employee_dao.any().employee_id
d1 = datetime(2013, 0o5, 26, 8)
self.server = JsonCallWrapper(ClockService(),
JsonCallWrapper.IN_PROCESS_MODE)
self.server.record_pointage_on_operation(
operation.operation_id, employee_id, d1, "nostromo",
TaskActionReportType.start_task, None)
d2 = datetime(2013, 5, 26, 10, 54)
self.server.record_pointage_on_operation(
operation.operation_id, employee_id, d2, "nostromo",
TaskActionReportType.stop_task, None)
order = dao.order_dao.find_by_id(widget._current_order.order_id)
operation = order.parts[0].production_file[0].operations[0]
widget.edit_new_order(
self.customer.customer_id) # Force the order reset below
app.processEvents()
widget.reset_order(order.order_id, overwrite=True)
widget.refresh_action()
m = widget.controller_operation.model
self.assertEqual(2.9, m.data(m.index(0, 4), Qt.UserRole))
m = widget.controller_part.model
self.assertEqual(80, m.data(m.index(0, 4), Qt.UserRole))
self.assertEqual(111, m.data(m.index(0, 6), Qt.UserRole))
def _fill_in_valid_credentials(self):
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_D) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_K) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Tab) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_K) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_K) # modifier, delay
self.app.processEvents()
def test_create_order_and_report_on_order(self):
# python test_integration.py TestEditOrderParts.test_create_order_and_report_on_order
app = self.app
widget = self.widget
mw = self.mw
clock_server = ClockServer(dao)
self._make_basic_preorder()
app.processEvents()
widget._set_state(OrderStatusType.order_ready_for_production)
self.prepare_to_click_dialog("confirm_estimate_sent")
# Save
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
app.processEvents()
app.processEvents()
self.assertTrue(widget._current_order.order_id > 0)
order = dao.order_dao.find_by_id(widget._current_order.order_id)
bc = BarCodeIdentifier.code_for(order, self.opdef_order)
employee_id = dao.employee_dao.any().employee_id
d1 = datetime(2013, 0o5, 26, 8)
# clock_server.recordPointage(bc,employee_id, datetime.strftime(d1, "%Y%m%dT%H:%M:%S"),"Nostromo")
d2 = datetime(2013, 0o5, 26, 10, 54)
# clock_server.recordPointage(bc,employee_id, datetime.strftime(d2, "%Y%m%dT%H:%M:%S"),"Nostromo")
self.server = JsonCallWrapper(ClockService(),
JsonCallWrapper.IN_PROCESS_MODE)
self.server.record_pointage_on_order(
order.order_id, self.opdef_order.operation_definition_id,
employee_id, d1, "nostromo", TaskActionReportType.start_task, None)
self.server.record_pointage_on_order(
order.order_id, self.opdef_order.operation_definition_id,
employee_id, d2, "nostromo", TaskActionReportType.stop_task, None)
order = dao.order_dao.find_by_id(widget._current_order.order_id)
widget.edit_new_order(
self.customer.customer_id) # Force the order reset below
app.processEvents()
widget.reset_order(order.order_id, overwrite=True)
app.processEvents()
def _click_context_menu(self):
mainlog.debug("hello " * 100)
active_widget = self.app.activePopupWidget()
mainlog.debug(active_widget)
# active_widget = self.app.focusWidget()
mainlog.debug(active_widget)
active_widget.setFocus()
#QApplication.
for i in range(10):
self.app.processEvents()
QTest.keyEvent(QTest.Click, active_widget, Qt.Key_Down) # enter menu
for i in range(10):
self.app.processEvents()
QTest.keyEvent(QTest.Click, active_widget,
Qt.Key_Down) # skip modify command
self.app.processEvents()
QTest.keyEvent(QTest.Click, active_widget,
Qt.Key_Down) # Skip priority
self.app.processEvents()
import time
for i in range(50):
# time.sleep(0.1)
self.app.processEvents()
QTest.keyEvent(
QTest.Click, active_widget,
Qt.Key_Enter) # At this point we're on "order part -> aborted"
self.app.processEvents()
mainlog.debug("_click_context_menu : done")
def test_encode_supply_order(self):
supplier = blank_dto(Supplier)
supplier.fullname = "Tessier-Ashpool"
supplier_id = supplier_service.save(supplier)
supplier = supplier_service.find_by_id(supplier_id)
self._pg_locks("on start")
app = self.app
widget = self.widget
widget.edit_new(supplier)
self.encode_text("PARTONE")
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
app.processEvents()
self.encode_text("11")
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
app.processEvents()
self.encode_text("22")
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
def test_encode_a_few_timetracks(self):
# python test_integration.py TestEditTimetracks.test_create_order_and_report_on_order
app = self.app
widget = self.widget
self._pg_locks("before init ")
widget.set_employee_and_date(self.employee.employee_id, date.today())
self._encode_imputable_operation(5)
self._pg_locks("after encoding a row")
widget.buttons.button(QDialogButtonBox.Ok).click()
self._pg_locks("after OK click")
# Now we check the time was actually reported
session().refresh(self._order)
self.assertEqual( 5.0, self._order.parts[0].total_hours)
session().commit()
self._pg_locks("after commit")
# Now we reopen the dialog and make sure our work still appears
# there.
widget.set_employee_and_date(self.employee.employee_id, date.today())
self._pg_locks("after set employee and before show")
widget.show()
self._pg_locks("After second show")
app.processEvents()
self._pg_locks("After process events")
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_F5, Qt.ShiftModifier) # modifier, delay
app.processEvents()
self._encode_imputable_operation()
app.processEvents()
widget.buttons.button(QDialogButtonBox.Ok).click()
# app.exec_()
self._pg_locks("when test finished")
def test_encode_normal_delivery_slip(self):
self._pg_locks("on start")
app = self.app
widget = self.widget
order = self._make_order()
order.parts[0].qty = 10
order.parts[0].sell_price = 10
self.order_dao.change_order_parts_state(
order.order_id, [order.parts[0].order_part_id],
OrderPartStateType.ready_for_production)
self.show_order(order)
widget.set_data(order.order_id)
widget.show()
widget._start_edit()
app.processEvents()
self._encode_part("5")
self._pg_locks()
for i in range(10000):
# print(i)
app.processEvents()
self.prepare_to_click_dialog("confirmDSCreation")
# from dialog_utils import confirmationBox
# confirmationBox("uytyutyutyutyu","iyiuyuiyiuyuiy","teststetstetsets")
# confirmationBox("uytyutyutyutyu","iyiuyuiyiuyuiy","teststetstetsets")
mainlog.debug("submit form")
for i in range(10000):
# print(i)
app.processEvents()
# Submit form
print((app.focusWidget()))
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Enter)
last_slip_id = self.delivery_slip_dao.find_last_slip_id()
ds = self.delivery_slip_dao.find_by_id(last_slip_id)
assert ds.delivery_slip_parts[0].quantity_out == 5
assert ds.delivery_slip_parts[0].order_part_id == order.parts[
0].order_part_id
def test_copy_paste_from_order_overview_to_order_edit(self):
order = self._make_order() # An order with one part
order_part = self._order_part_dao.make(order)
order_part.description = u"Part 2"
order_part.notes = "Notes 2"
order_part.position = 2
self._order_part_dao.save(order_part)
order_part = self._order_part_dao.make(order)
order_part.description = u"Part 3"
order_part.notes = "Notes 3"
order_part.position = 3
self._order_part_dao.save(order_part)
self._order_dao.change_order_state(
order.order_id, OrderStatusType.order_ready_for_production)
# self._order_dao.recompute_position_labels(order)
ops = self.dao.operation_dao.operations_for_order_parts_frozen(
[1011, 1014, 1013])
assert ops[1011]
assert 1013 not in ops
assert 1014 not in ops
self.stack.setCurrentWidget(self.order_overview_widget)
# self.order_overview_widget.month_today()
self.order_overview_widget.refresh_action()
self.order_overview_widget.retake_focus()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_A,
Qt.ControlModifier) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_C,
Qt.ControlModifier) # modifier, delay
self.app.processEvents()
# Now that we have copied, we'd like to paste !
self.stack.setCurrentWidget(self.edit_order_widget)
self.edit_order_widget.edit_new_order(self.customer.customer_id)
self.edit_order_widget.controller_part.view.setFocus(
Qt.OtherFocusReason)
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_V,
Qt.ControlModifier) # modifier, delay
self.app.processEvents()
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
self.app.processEvents()
order = self.order_dao.find_by_id(order.order_id)
self.assertEqual(3, len(order.parts))
self.assertEqual(1, len(order.parts[0].operations))
self.assertEqual(0, len(order.parts[1].operations))
self.assertEqual(u"Notes 2", order.parts[1].notes)
self.assertEqual(u"Notes 3", order.parts[2].notes)
def test_edit_order_documents(self):
app = self.app
widget = self.widget
mw = self.mw
# order = self._make_order()
# order_id = order.order_id
# widget.reset_order(order.order_id)
widget.edit_new_order(self.customer_id)
widget.controller_part.view.setFocus(Qt.OtherFocusReason)
# QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_Escape) # modifier, delay
# QTest.keyEvent(QTest.Click, widget.controller_part.view, Qt.Key_F5, Qt.ShiftModifier) # modifier, delay
# app.processEvents()
self._fill_order_part("Order part two")
# Put the cursor back on the first line so the next document drop is tied to it.
QTest.keyEvent(QTest.Click, widget.controller_part.view, Qt.Key_Up)
app.processEvents()
# app.exec_()
tmp_file, tmp_path = self._make_tmp_file()
mime_data = QMimeData()
url = "file:///{}".format(os.path.abspath(tmp_path).replace('\\', '/'))
mainlog.debug("Dropping at {}".format(QUrl(url).toString()))
mime_data.setUrls([QUrl(url)])
make_document_drop(widget.documents_widget.view, QPoint(10, 10),
mime_data)
self._clear_tmp_file(tmp_file, tmp_path)
# That's fine, but I'll need to pilot the file chooser dialog, and that's hard :-(
# But even if I find my way around that, I'll have to mock the file server... :-(
# b.click()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
order = dao.order_dao.find_by_id(widget._current_order.order_id)
#app.exec_()
self.assertEqual(1, len(order.parts[0].documents),
"One document was added on the first part")
def test_find_happy(self):
order = self._make_order()
dao.order_dao.save(order)
session().commit()
self.show_order(order)
b = self.widget.buttons.button(QDialogButtonBox.Ok)
mainlog.debug(str(order.preorder_label))
self.widget.search_criteria.setText(str(order.accounting_label))
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Enter)
self.app.processEvents()
self.assertEqual(1, self.widget.search_results_model.rowCount())
def _accept_open_dialog(self):
if self.timer_has_run_once:
return
else:
self.timer_has_run_once = True
self.timer.stop()
dialog_object_name = self.dialog_to_click[0]
self.dialog_to_click = self.dialog_to_click[1:len(self.dialog_to_click
)]
trail = ""
o = self.app.activeModalWidget()
mainlog.debug(
"Looking for {}. Currently focused widget is {} (name = {})".
format(dialog_object_name, o, o.objectName()))
while o and o.objectName() != dialog_object_name:
trail += str(o.objectName()) + ","
o = o.parent()
if o:
mainlog.debug("timer triggered the expected click on {}".format(
dialog_object_name))
self.dialog_test_result = True
QTest.keyEvent(QTest.Click, self.app.activeModalWidget(),
Qt.Key_Enter)
mainlog.debug("Clicked on {} !".format(dialog_object_name))
if len(self.dialog_to_click) > 0:
mainlog.debug("timer triggered again on {}".format(
self.dialog_to_click[0]))
self.timer_has_run_once = False
self.timer.start(1000)
else:
# You must assert on dialog_test_result otherwise the failure
# won't be seen (even igf you do self.fail() down here...)
# I think it's because PySide still catches exceptions even
# after self.app.exit()
self.dialog_test_result = False
# self.app.exit()
mainlog.error(
"Didn't find the expected widget {}. The trail was {}".format(
dialog_object_name, trail))
def test_new_order_is_a_preorder(self): # passes
app = self.app
widget = self.widget
mw = self.mw
mainlog.debug(str(self.customer))
widget.edit_new_order(self.customer.customer_id)
#app.exec_()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
order = dao.order_dao.find_by_id(widget._current_order.order_id)
assert order.state == OrderStatusType.preorder_definition
assert order.preorder_label is not None
assert order.accounting_label == None
def test_new_order_is_not_a_preorder(self): # passes
app = self.app
widget = self.widget
mw = self.mw
widget.edit_new_order(self.customer.customer_id)
widget.order_state_label.set_value(
OrderStatusType.order_ready_for_production)
self.prepare_to_click_dialog("confirm_estimate")
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
order = dao.order_dao.find_by_id(widget._current_order.order_id)
assert order.state == OrderStatusType.order_ready_for_production
assert order.preorder_label is None
assert order.accounting_label is not None
def test_find_fails(self):
self._make_order()
session().commit()
self._make_order()
session().commit()
self.widget.search_criteria.setText("A")
self.prepare_to_click_dialog("filter_is_too_short")
print("1" * 10)
self._fix_focus(self.widget, self.widget.search_criteria)
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Enter)
print("2" * 10)
self.widget.search_criteria.setText("")
self.prepare_to_click_dialog("filter_is_empty")
self._fix_focus(self.widget, self.widget.search_criteria)
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Enter)
print("3" * 10)
# Monkey patching !
old_max = dao.order_part_dao.MAX_RESULTS
dao.order_part_dao.MAX_RESULTS = 1
self.widget.search_criteria.setText(self.customer.fullname)
self.prepare_to_click_dialog("too_many_results")
self._fix_focus(self.widget, self.widget.search_criteria)
QTest.keyEvent(QTest.Click, self.app.focusWidget(), Qt.Key_Enter)
self.assertEqual(1, self.widget.search_results_model.rowCount())
dao.order_part_dao.MAX_RESULTS = old_max
def encode_text(self, text):
k = [
Qt.Key_0, Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_4, Qt.Key_5,
Qt.Key_6, Qt.Key_7, Qt.Key_8, Qt.Key_9, Qt.Key_A, Qt.Key_B,
Qt.Key_C, Qt.Key_D, Qt.Key_E, Qt.Key_F, Qt.Key_G, Qt.Key_H,
Qt.Key_I, Qt.Key_J, Qt.Key_K, Qt.Key_L, Qt.Key_M, Qt.Key_N,
Qt.Key_O, Qt.Key_P, Qt.Key_Q, Qt.Key_R, Qt.Key_S, Qt.Key_T,
Qt.Key_U, Qt.Key_V, Qt.Key_W, Qt.Key_X, Qt.Key_Y, Qt.Key_Z
]
k = dict(
list(
zip([
"z{}".format(c)
for c in "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
], k)))
app = self.app
for digit in text:
kdigit = "z{}".format(digit)
QTest.keyEvent(QTest.Click, app.focusWidget(),
k[kdigit]) # modifier, delay
app.processEvents()
def test_mix_with_timetracks_managed_by_code(self):
today = date.today()
tt = dao.timetrack_dao.create(self.nb_task,self.employee,12,datetime.now(),today)
tt.managed_by_code = True
dao.timetrack_dao._recompute_presence_on_timetracks(self.employee.employee_id,today,[tt])
session().commit()
app = self.app
widget = self.widget
self._pg_locks("before init ")
widget.set_employee_and_date(self.employee.employee_id, today)
self._fix_focus(widget, widget.controller.view)
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_F5, Qt.ShiftModifier) # modifier, delay
app.processEvents()
self._encode_imputable_operation(5)
widget.buttons.button(QDialogButtonBox.Ok).click()
tts = dao.timetrack_dao.all_work_for_employee_date(self.employee.employee_id,today)
self.assertEqual(12.0 + 5.0, sum([tt.duration for tt in tts]))
self.assertEqual(2,len(tts))
def test_delete_an_operation(self):
# python test_integration.py TestEditOrderParts.test_delete_an_operation
order = self._make_order()
order_id = order.order_id
app = self.app
widget = self.widget
widget.reset_order(order.order_id, overwrite=True)
widget.refresh_action()
session().close()
widget.controller_operation.view.setFocus(Qt.OtherFocusReason)
QTest.keyEvent(QTest.Click, app.focusWidget(),
Qt.Key_F8) # modifier, delay
app.processEvents()
QTest.keyEvent(QTest.Click, app.focusWidget(), Qt.Key_S,
Qt.ControlModifier) # modifier, delay
app.processEvents()
order = dao.order_dao.find_by_id(order_id)
self.assertTrue(not order.parts[0].operations)
