580 lines
19 KiB
Python
580 lines
19 KiB
Python
from unittest.mock import patch
|
|
|
|
from PySide6.QtCore import QDate
|
|
from PySide6.QtWidgets import QDialog, QMessageBox
|
|
|
|
from bouquin.projects import (
|
|
ProjectsDialog,
|
|
format_bucket_status,
|
|
hours_from_minutes,
|
|
minutes_from_hours,
|
|
)
|
|
from bouquin.time_log import TimeLogDialog, TimeReportDialog
|
|
|
|
|
|
def _add_project(fresh_db, project_name: str) -> int:
|
|
project_id = fresh_db.add_project(project_name)
|
|
fresh_db.upsert_project_billing(
|
|
project_id,
|
|
hourly_rate_cents=15000,
|
|
currency="AUD",
|
|
tax_label="GST",
|
|
tax_rate_percent=10.0,
|
|
client_name=f"{project_name} Contact",
|
|
client_company=project_name,
|
|
client_address="1 Example Street",
|
|
client_email="client@example.test",
|
|
)
|
|
return project_id
|
|
|
|
|
|
def _add_minutes(fresh_db, project_id: int, minutes: int, note: str = "Work") -> int:
|
|
activity_id = fresh_db.add_activity("Support")
|
|
return fresh_db.add_time_log("2026-01-01", project_id, activity_id, minutes, note)
|
|
|
|
|
|
# ============================================================================
|
|
# Unit helpers
|
|
# ============================================================================
|
|
|
|
|
|
def test_project_hour_minute_helpers_round_trip():
|
|
assert hours_from_minutes(None) == 0.0
|
|
assert hours_from_minutes(90) == 1.5
|
|
assert minutes_from_hours(None) == 0
|
|
assert minutes_from_hours(1.25) == 75
|
|
assert minutes_from_hours(1.333) == 80
|
|
|
|
|
|
def test_format_bucket_status_handles_none_unconfigured_and_reached(fresh_db):
|
|
assert "Select a project" in format_bucket_status(None)
|
|
|
|
project_id = _add_project(fresh_db, "No Bucket Project")
|
|
_add_minutes(fresh_db, project_id, 30)
|
|
unconfigured = fresh_db.project_bucket_status(project_id)
|
|
text = format_bucket_status(unconfigured)
|
|
assert "No Bucket Project" in text
|
|
assert "No bucket ceiling" in text
|
|
assert "0.50h used" in text
|
|
|
|
fresh_db.upsert_project_bucket(project_id, 30, 60, 50.0)
|
|
reached = fresh_db.project_bucket_status(project_id)
|
|
text = format_bucket_status(reached)
|
|
assert "1.00h / 1.00h" in text
|
|
assert "Bucket ceiling reached" in text
|
|
|
|
|
|
# ============================================================================
|
|
# DB behaviour
|
|
# ============================================================================
|
|
|
|
|
|
def test_project_bucket_status_includes_baseline_and_logged_time(fresh_db):
|
|
project_id = _add_project(fresh_db, "Support Retainer")
|
|
_add_minutes(fresh_db, project_id, 90)
|
|
fresh_db.upsert_project_bucket(
|
|
project_id,
|
|
baseline_minutes=60,
|
|
bucket_ceiling_minutes=180,
|
|
warn_at_percent=80.0,
|
|
)
|
|
|
|
status = fresh_db.project_bucket_status(project_id)
|
|
assert status["project_id"] == project_id
|
|
assert status["project_name"] == "Support Retainer"
|
|
assert status["baseline_minutes"] == 60
|
|
assert status["logged_minutes"] == 90
|
|
assert status["used_minutes"] == 150
|
|
assert status["remaining_minutes"] == 30
|
|
assert status["percent_used"] == 150 / 180 * 100.0
|
|
assert status["state"] == "warning"
|
|
|
|
fresh_db.add_to_project_bucket_ceiling(project_id, 60)
|
|
status = fresh_db.project_bucket_status(project_id)
|
|
assert status["bucket_ceiling_minutes"] == 240
|
|
assert status["state"] == "ok"
|
|
|
|
|
|
def test_project_bucket_status_state_boundaries(fresh_db):
|
|
project_id = _add_project(fresh_db, "Boundary Project")
|
|
|
|
_add_minutes(fresh_db, project_id, 30)
|
|
status = fresh_db.project_bucket_status(project_id)
|
|
assert status["state"] == "unconfigured"
|
|
assert status["bucket_ceiling_minutes"] == 0
|
|
assert status["remaining_minutes"] is None
|
|
assert status["percent_used"] is None
|
|
|
|
fresh_db.upsert_project_bucket(project_id, 0, 120, 80.0)
|
|
assert fresh_db.project_bucket_status(project_id)["state"] == "ok"
|
|
|
|
fresh_db.upsert_project_bucket(project_id, 66, 120, 80.0)
|
|
status = fresh_db.project_bucket_status(project_id)
|
|
assert status["used_minutes"] == 96
|
|
assert status["percent_used"] == 80.0
|
|
assert status["state"] == "warning"
|
|
|
|
fresh_db.upsert_project_bucket(project_id, 90, 120, 80.0)
|
|
status = fresh_db.project_bucket_status(project_id)
|
|
assert status["used_minutes"] == 120
|
|
assert status["remaining_minutes"] == 0
|
|
assert status["state"] == "reached"
|
|
|
|
fresh_db.upsert_project_bucket(project_id, 91, 120, 80.0)
|
|
status = fresh_db.project_bucket_status(project_id)
|
|
assert status["used_minutes"] == 121
|
|
assert status["remaining_minutes"] == -1
|
|
assert status["state"] == "exceeded"
|
|
|
|
|
|
def test_project_bucket_input_sanitisation_and_invalid_projects(fresh_db):
|
|
project_id = _add_project(fresh_db, "Sanitised Project")
|
|
fresh_db.upsert_project_bucket(
|
|
project_id,
|
|
baseline_minutes=-60,
|
|
bucket_ceiling_minutes=-120,
|
|
warn_at_percent=150.0,
|
|
)
|
|
bucket = fresh_db.get_project_bucket(project_id)
|
|
assert bucket["project_id"] == project_id
|
|
assert bucket["baseline_minutes"] == 0
|
|
assert bucket["bucket_ceiling_minutes"] == 0
|
|
assert bucket["warn_at_percent"] == 100.0
|
|
|
|
fresh_db.upsert_project_bucket(project_id, 10, 60, -5.0)
|
|
bucket = fresh_db.get_project_bucket(project_id)
|
|
assert bucket["warn_at_percent"] == 0.0
|
|
|
|
fresh_db.add_to_project_bucket_ceiling(project_id, -60)
|
|
assert fresh_db.get_project_bucket(project_id)["bucket_ceiling_minutes"] == 60
|
|
|
|
for bad_project_id in (0, -1):
|
|
try:
|
|
fresh_db.upsert_project_bucket(bad_project_id, 0, 60, 80.0)
|
|
except ValueError as exc:
|
|
assert "invalid project id" in str(exc)
|
|
else:
|
|
raise AssertionError("invalid project id should raise")
|
|
|
|
assert fresh_db.get_project_bucket(0) is None
|
|
assert fresh_db.logged_minutes_for_project(0) == 0
|
|
assert fresh_db.project_bucket_status(0) is None
|
|
assert fresh_db.time_logs_for_project(0) == []
|
|
assert fresh_db.invoices_for_project_with_documents(0) == []
|
|
|
|
|
|
def test_project_summaries_include_all_projects_and_are_sorted(fresh_db):
|
|
alpha = _add_project(fresh_db, "alpha project")
|
|
zulu = _add_project(fresh_db, "Zulu Project")
|
|
fresh_db.upsert_project_bucket(zulu, 15, 120, 80.0)
|
|
|
|
rows = fresh_db.list_project_summaries()
|
|
names = [r["project_name"] for r in rows]
|
|
assert names == ["alpha project", "Zulu Project"]
|
|
|
|
alpha_row = next(r for r in rows if r["project_id"] == alpha)
|
|
assert alpha_row["document_count"] == 0
|
|
assert alpha_row["invoice_count"] == 0
|
|
assert alpha_row["time_log_count"] == 0
|
|
assert alpha_row["logged_minutes"] == 0
|
|
assert alpha_row["baseline_minutes"] == 0
|
|
|
|
zulu_row = next(r for r in rows if r["project_id"] == zulu)
|
|
assert zulu_row["baseline_minutes"] == 15
|
|
assert zulu_row["bucket_ceiling_minutes"] == 120
|
|
|
|
|
|
def test_project_documents_time_logs_and_invoices_are_isolated(fresh_db, tmp_path):
|
|
project_id = _add_project(fresh_db, "Project With Docs")
|
|
other_project = _add_project(fresh_db, "Other Project")
|
|
_add_minutes(fresh_db, project_id, 120, "Build work")
|
|
_add_minutes(fresh_db, other_project, 300, "Other work")
|
|
fresh_db.upsert_project_bucket(project_id, 0, 240, 80.0)
|
|
|
|
doc_path = tmp_path / "invoice.pdf"
|
|
doc_path.write_bytes(b"not really a pdf")
|
|
doc_id = fresh_db.add_document_from_path(
|
|
project_id,
|
|
str(doc_path),
|
|
description="Invoice document",
|
|
uploaded_at="2026-02-02",
|
|
)
|
|
|
|
other_doc = tmp_path / "other.pdf"
|
|
other_doc.write_bytes(b"other")
|
|
fresh_db.add_document_from_path(other_project, str(other_doc))
|
|
|
|
invoice_id = fresh_db.create_invoice(
|
|
project_id=project_id,
|
|
invoice_number="INV-1",
|
|
issue_date="2026-02-03",
|
|
due_date="2026-02-17",
|
|
currency="AUD",
|
|
tax_label=None,
|
|
tax_rate_percent=None,
|
|
detail_mode="summary",
|
|
line_items=[("Prepaid bucket", 2.0, 10000)],
|
|
time_log_ids=[],
|
|
)
|
|
fresh_db.set_invoice_document(invoice_id, doc_id)
|
|
fresh_db.create_invoice(
|
|
project_id=other_project,
|
|
invoice_number="INV-OTHER",
|
|
issue_date="2026-02-03",
|
|
due_date="2026-02-17",
|
|
currency="AUD",
|
|
tax_label=None,
|
|
tax_rate_percent=None,
|
|
detail_mode="summary",
|
|
line_items=[("Other", 1.0, 10000)],
|
|
time_log_ids=[],
|
|
)
|
|
|
|
row = next(
|
|
r for r in fresh_db.list_project_summaries() if r["project_id"] == project_id
|
|
)
|
|
assert row["logged_minutes"] == 120
|
|
assert row["time_log_count"] == 1
|
|
assert row["document_count"] == 1
|
|
assert row["invoice_count"] == 1
|
|
|
|
logs = fresh_db.time_logs_for_project(project_id)
|
|
assert len(logs) == 1
|
|
assert logs[0]["note"] == "Build work"
|
|
|
|
docs = fresh_db.documents_for_project(project_id)
|
|
assert len(docs) == 1
|
|
assert docs[0][3] == "invoice.pdf"
|
|
|
|
invoices = fresh_db.invoices_for_project_with_documents(project_id)
|
|
assert len(invoices) == 1
|
|
assert invoices[0]["invoice_number"] == "INV-1"
|
|
assert invoices[0]["document_id"] == doc_id
|
|
assert invoices[0]["document_file_name"] == "invoice.pdf"
|
|
|
|
|
|
def test_prepaid_invoice_can_exist_without_logged_time_links(fresh_db):
|
|
project_id = _add_project(fresh_db, "Prepaid Project")
|
|
|
|
invoice_id = fresh_db.create_invoice(
|
|
project_id=project_id,
|
|
invoice_number="PREPAID-1",
|
|
issue_date="2026-02-10",
|
|
due_date="2026-02-24",
|
|
currency="AUD",
|
|
tax_label=None,
|
|
tax_rate_percent=None,
|
|
detail_mode="summary",
|
|
line_items=[("Prepaid support bucket", 40.0, 15000)],
|
|
time_log_ids=[],
|
|
)
|
|
|
|
invoice = fresh_db.invoices_for_project_with_documents(project_id)[0]
|
|
assert invoice["id"] == invoice_id
|
|
assert invoice["total_cents"] == 600000
|
|
|
|
linked = fresh_db.conn.execute(
|
|
"SELECT COUNT(*) AS c FROM invoice_time_log WHERE invoice_id = ?",
|
|
(invoice_id,),
|
|
).fetchone()
|
|
assert linked["c"] == 0
|
|
|
|
|
|
# ============================================================================
|
|
# UI behaviour
|
|
# ============================================================================
|
|
|
|
|
|
def test_projects_dialog_loads_summary_time_logs_documents_and_invoices(
|
|
qtbot, fresh_db, tmp_path
|
|
):
|
|
project_id = _add_project(fresh_db, "UI Project")
|
|
_add_minutes(fresh_db, project_id, 60, "Initial support")
|
|
fresh_db.upsert_project_bucket(project_id, 30, 120, 75.0)
|
|
|
|
doc_path = tmp_path / "ui-invoice.pdf"
|
|
doc_path.write_bytes(b"ui")
|
|
doc_id = fresh_db.add_document_from_path(
|
|
project_id,
|
|
str(doc_path),
|
|
description="UI invoice",
|
|
uploaded_at="2026-03-01",
|
|
)
|
|
invoice_id = fresh_db.create_invoice(
|
|
project_id,
|
|
"UI-1",
|
|
"2026-03-02",
|
|
"2026-03-16",
|
|
"AUD",
|
|
None,
|
|
None,
|
|
"summary",
|
|
[("UI work", 1.0, 10000)],
|
|
[],
|
|
)
|
|
fresh_db.set_invoice_document(invoice_id, doc_id)
|
|
|
|
dialog = ProjectsDialog(fresh_db)
|
|
qtbot.addWidget(dialog)
|
|
|
|
assert dialog.project_combo.currentData() == project_id
|
|
assert dialog.summary_table.rowCount() == 1
|
|
assert dialog.time_logs_table.rowCount() == 1
|
|
assert dialog.documents_table.rowCount() == 1
|
|
assert dialog.invoices_table.rowCount() == 1
|
|
assert dialog.summary_table.item(0, dialog.SUM_USED).text() == "1.50"
|
|
assert (
|
|
dialog.summary_table.item(0, dialog.SUM_STATE).text()
|
|
== "Approaching bucket ceiling"
|
|
)
|
|
assert dialog.time_logs_table.item(0, dialog.LOG_NOTE).text() == "Initial support"
|
|
assert dialog.documents_table.item(0, dialog.DOC_FILE).text() == "ui-invoice.pdf"
|
|
assert dialog.invoices_table.item(0, dialog.INV_NUMBER).text() == "UI-1"
|
|
assert "UI Project" in dialog.status_label.text()
|
|
assert "1.50h / 2.00h" in dialog.status_label.text()
|
|
assert (
|
|
dialog.status_label.minimumHeight()
|
|
>= dialog.status_label.fontMetrics().lineSpacing() * 3 + 18
|
|
)
|
|
|
|
|
|
def test_projects_dialog_saves_and_replenishes_bucket(qtbot, fresh_db):
|
|
project_id = _add_project(fresh_db, "Editable Project")
|
|
|
|
dialog = ProjectsDialog(fresh_db)
|
|
qtbot.addWidget(dialog)
|
|
assert dialog.project_combo.currentData() == project_id
|
|
|
|
dialog.baseline_spin.setValue(1.5)
|
|
dialog.ceiling_spin.setValue(10.0)
|
|
dialog.warn_spin.setValue(75.0)
|
|
dialog._save_bucket()
|
|
|
|
bucket = fresh_db.get_project_bucket(project_id)
|
|
assert bucket["baseline_minutes"] == 90
|
|
assert bucket["bucket_ceiling_minutes"] == 600
|
|
assert bucket["warn_at_percent"] == 75.0
|
|
|
|
dialog.topup_spin.setValue(40.0)
|
|
dialog._add_to_ceiling()
|
|
|
|
bucket = fresh_db.get_project_bucket(project_id)
|
|
assert bucket["bucket_ceiling_minutes"] == 3000
|
|
assert "48.50h remaining" in dialog.status_label.text()
|
|
|
|
|
|
class _FakeRadioButton:
|
|
def __init__(self):
|
|
self.checked = False
|
|
|
|
def setChecked(self, checked):
|
|
self.checked = checked
|
|
|
|
|
|
class _FakeLineEdit:
|
|
def __init__(self):
|
|
self.value = ""
|
|
|
|
def setText(self, text):
|
|
self.value = text
|
|
|
|
|
|
class _FakeSpinBox:
|
|
def __init__(self):
|
|
self.value_set = None
|
|
|
|
def setValue(self, value):
|
|
self.value_set = value
|
|
|
|
|
|
class _FakeInvoiceDialog:
|
|
instances = []
|
|
|
|
def __init__(
|
|
self, db, project_id, start_date_iso, end_date_iso, time_rows=None, parent=None
|
|
):
|
|
self.db = db
|
|
self.project_id = project_id
|
|
self.start_date_iso = start_date_iso
|
|
self.end_date_iso = end_date_iso
|
|
self.time_rows = time_rows
|
|
self.parent = parent
|
|
self.rb_summary = _FakeRadioButton()
|
|
self.summary_desc_edit = _FakeLineEdit()
|
|
self.summary_hours_spin = _FakeSpinBox()
|
|
self.recalculated = False
|
|
self.executed = False
|
|
_FakeInvoiceDialog.instances.append(self)
|
|
|
|
def _recalc_totals(self):
|
|
self.recalculated = True
|
|
|
|
def exec(self):
|
|
self.executed = True
|
|
return QDialog.Accepted
|
|
|
|
|
|
def test_projects_dialog_can_open_prepaid_invoice_for_unspent_hours(qtbot, fresh_db):
|
|
project_id = _add_project(fresh_db, "Prepaid UI Project")
|
|
dialog = ProjectsDialog(fresh_db)
|
|
qtbot.addWidget(dialog)
|
|
dialog.topup_spin.setValue(40.0)
|
|
|
|
_FakeInvoiceDialog.instances.clear()
|
|
with patch("bouquin.projects.InvoiceDialog", _FakeInvoiceDialog):
|
|
dialog._invoice_prepaid_hours()
|
|
|
|
assert len(_FakeInvoiceDialog.instances) == 1
|
|
invoice_dialog = _FakeInvoiceDialog.instances[0]
|
|
assert invoice_dialog.db is fresh_db
|
|
assert invoice_dialog.project_id == project_id
|
|
assert invoice_dialog.time_rows == []
|
|
assert invoice_dialog.parent is dialog
|
|
assert invoice_dialog.rb_summary.checked is True
|
|
assert invoice_dialog.summary_hours_spin.value_set == 40.0
|
|
assert invoice_dialog.summary_desc_edit.value == (
|
|
"Prepaid support bucket (40.00 hours)"
|
|
)
|
|
assert invoice_dialog.recalculated is True
|
|
assert invoice_dialog.executed is True
|
|
|
|
|
|
def test_projects_dialog_warns_when_prepaid_invoice_hours_are_zero(qtbot, fresh_db):
|
|
_add_project(fresh_db, "Zero Project")
|
|
dialog = ProjectsDialog(fresh_db)
|
|
qtbot.addWidget(dialog)
|
|
dialog.topup_spin.setValue(0.0)
|
|
|
|
with patch.object(QMessageBox, "warning") as warning:
|
|
dialog._invoice_prepaid_hours()
|
|
|
|
assert warning.called
|
|
assert "greater than zero" in warning.call_args.args[2]
|
|
|
|
|
|
def test_projects_dialog_opens_selected_document_and_invoice_document(
|
|
qtbot, fresh_db, tmp_path
|
|
):
|
|
project_id = _add_project(fresh_db, "Open Project")
|
|
doc_path = tmp_path / "open.pdf"
|
|
doc_path.write_bytes(b"open")
|
|
doc_id = fresh_db.add_document_from_path(project_id, str(doc_path))
|
|
invoice_id = fresh_db.create_invoice(
|
|
project_id,
|
|
"OPEN-1",
|
|
"2026-05-01",
|
|
None,
|
|
"AUD",
|
|
None,
|
|
None,
|
|
"summary",
|
|
[("Open work", 1.0, 10000)],
|
|
[],
|
|
)
|
|
fresh_db.set_invoice_document(invoice_id, doc_id)
|
|
|
|
dialog = ProjectsDialog(fresh_db)
|
|
qtbot.addWidget(dialog)
|
|
|
|
dialog.documents_table.selectRow(0)
|
|
with patch("bouquin.projects.open_document_from_db") as open_doc:
|
|
dialog._open_selected_document()
|
|
open_doc.assert_called_once_with(
|
|
fresh_db, doc_id, "open.pdf", parent_widget=dialog
|
|
)
|
|
|
|
dialog.invoices_table.selectRow(0)
|
|
with patch("bouquin.projects.open_document_from_db") as open_doc:
|
|
dialog._open_invoice_document()
|
|
open_doc.assert_called_once_with(
|
|
fresh_db, doc_id, "open.pdf", parent_widget=dialog
|
|
)
|
|
|
|
|
|
def test_projects_dialog_reports_missing_invoice_document(qtbot, fresh_db):
|
|
project_id = _add_project(fresh_db, "No Doc Project")
|
|
fresh_db.create_invoice(
|
|
project_id,
|
|
"NO-DOC-1",
|
|
"2026-05-01",
|
|
None,
|
|
"AUD",
|
|
None,
|
|
None,
|
|
"summary",
|
|
[("Work", 1.0, 10000)],
|
|
[],
|
|
)
|
|
|
|
dialog = ProjectsDialog(fresh_db)
|
|
qtbot.addWidget(dialog)
|
|
dialog.invoices_table.selectRow(0)
|
|
|
|
with patch.object(QMessageBox, "information") as info:
|
|
dialog._open_invoice_document()
|
|
assert info.called
|
|
|
|
|
|
def test_time_log_dialog_updates_bucket_indicator_and_alerts_on_reach(qtbot, fresh_db):
|
|
project_id = _add_project(fresh_db, "Logging Project")
|
|
fresh_db.upsert_project_bucket(project_id, 0, 60, 80.0)
|
|
|
|
dialog = TimeLogDialog(fresh_db, "2026-06-01")
|
|
qtbot.addWidget(dialog)
|
|
|
|
idx = dialog.project_combo.findData(project_id)
|
|
dialog.project_combo.setCurrentIndex(idx)
|
|
assert "0.00h / 1.00h" in dialog.bucket_label.text()
|
|
assert "Status: OK" in dialog.bucket_label.text()
|
|
|
|
dialog.activity_edit.setText("Support")
|
|
dialog.hours_spin.setValue(1.0)
|
|
|
|
with patch.object(QMessageBox, "warning") as warning:
|
|
dialog._on_add_or_update()
|
|
assert warning.called
|
|
assert "Bucket ceiling reached" in warning.call_args.args[2]
|
|
|
|
status = fresh_db.project_bucket_status(project_id)
|
|
assert status["state"] == "reached"
|
|
assert "Bucket ceiling reached" in dialog.bucket_label.text()
|
|
|
|
|
|
def test_time_log_dialog_does_not_alert_before_reaching_bucket(qtbot, fresh_db):
|
|
project_id = _add_project(fresh_db, "Safe Logging")
|
|
fresh_db.upsert_project_bucket(project_id, 0, 120, 80.0)
|
|
|
|
dialog = TimeLogDialog(fresh_db, "2026-06-02")
|
|
qtbot.addWidget(dialog)
|
|
dialog.project_combo.setCurrentIndex(dialog.project_combo.findData(project_id))
|
|
dialog.activity_edit.setText("Support")
|
|
dialog.hours_spin.setValue(0.5)
|
|
|
|
with patch.object(QMessageBox, "warning") as warning:
|
|
dialog._on_add_or_update()
|
|
warning.assert_not_called()
|
|
|
|
assert fresh_db.project_bucket_status(project_id)["state"] == "ok"
|
|
|
|
|
|
def test_time_report_dialog_shows_bucket_for_selected_project_and_clears_for_all(
|
|
qtbot, fresh_db
|
|
):
|
|
project_id = _add_project(fresh_db, "Report Project")
|
|
_add_minutes(fresh_db, project_id, 90)
|
|
fresh_db.upsert_project_bucket(project_id, 0, 120, 75.0)
|
|
|
|
dialog = TimeReportDialog(fresh_db)
|
|
qtbot.addWidget(dialog)
|
|
|
|
dialog.from_date.setDate(QDate.fromString("2026-01-01", "yyyy-MM-dd"))
|
|
dialog.to_date.setDate(QDate.fromString("2026-01-31", "yyyy-MM-dd"))
|
|
|
|
dialog.project_combo.setCurrentIndex(dialog.project_combo.findData(project_id))
|
|
dialog._run_report()
|
|
assert "Report Project" in dialog.bucket_label.text()
|
|
assert "Approaching bucket ceiling" in dialog.bucket_label.text()
|
|
|
|
dialog.project_combo.setCurrentIndex(dialog.project_combo.findData(None))
|
|
dialog._run_report()
|
|
assert dialog.bucket_label.text() == ""
|