diff --git a/frappe/automation/doctype/assignment_rule/test_assignment_rule.py b/frappe/automation/doctype/assignment_rule/test_assignment_rule.py index 8f1773608f..45a1b85291 100644 --- a/frappe/automation/doctype/assignment_rule/test_assignment_rule.py +++ b/frappe/automation/doctype/assignment_rule/test_assignment_rule.py @@ -4,7 +4,8 @@ import frappe from frappe.test_runner import make_test_records from frappe.tests.utils import FrappeTestCase -from frappe.utils import random_string + +TEST_DOCTYPE = "Assignment Test" class TestAutoAssign(FrappeTestCase): @@ -12,6 +13,7 @@ class TestAutoAssign(FrappeTestCase): def setUpClass(cls): super().setUpClass() frappe.db.delete("Assignment Rule") + create_test_doctype(TEST_DOCTYPE) @classmethod def tearDownClass(cls): @@ -33,45 +35,49 @@ class TestAutoAssign(FrappeTestCase): clear_assignments() def test_round_robin(self): - note = make_note(dict(public=1)) - # check if auto assigned to first user + record = _make_test_record(public=1) self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=record.name, status="Open"), + "allocated_to", ), "test@example.com", ) - note = make_note(dict(public=1)) - # check if auto assigned to second user + record = _make_test_record(public=1) self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=record.name, status="Open"), + "allocated_to", ), "test1@example.com", ) clear_assignments() - note = make_note(dict(public=1)) - # check if auto assigned to third user, even if # previous assignments where closed + record = _make_test_record(public=1) self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=record.name, status="Open"), + "allocated_to", ), "test2@example.com", ) # check loop back to first user - note = make_note(dict(public=1)) - + record = _make_test_record(public=1) self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=record.name, status="Open"), + "allocated_to", ), "test@example.com", ) @@ -81,29 +87,29 @@ class TestAutoAssign(FrappeTestCase): self.assignment_rule.save() for _ in range(30): - note = make_note(dict(public=1)) + _make_test_record(public=1) # check if each user has 10 assignments (?) for user in ("test@example.com", "test1@example.com", "test2@example.com"): self.assertEqual( - len(frappe.get_all("ToDo", dict(allocated_to=user, reference_type="Note"))), 10 + len(frappe.get_all("ToDo", dict(allocated_to=user, reference_type=TEST_DOCTYPE))), 10 ) # clear 5 assignments for first user # can't do a limit in "delete" since postgres does not support it for d in frappe.get_all( - "ToDo", dict(reference_type="Note", allocated_to="test@example.com"), limit=5 + "ToDo", dict(reference_type=TEST_DOCTYPE, allocated_to="test@example.com"), limit=5 ): frappe.db.delete("ToDo", {"name": d.name}) # add 5 more assignments for i in range(5): - make_note(dict(public=1)) + _make_test_record(public=1) # check if each user still has 10 assignments for user in ("test@example.com", "test1@example.com", "test2@example.com"): self.assertEqual( - len(frappe.get_all("ToDo", dict(allocated_to=user, reference_type="Note"))), 10 + len(frappe.get_all("ToDo", dict(allocated_to=user, reference_type=TEST_DOCTYPE))), 10 ) def test_based_on_field(self): @@ -112,21 +118,21 @@ class TestAutoAssign(FrappeTestCase): self.assignment_rule.save() frappe.set_user("test1@example.com") - note = make_note(dict(public=1)) + note = _make_test_record(public=1) # check if auto assigned to doc owner, test1@example.com self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "owner" + "ToDo", dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), "owner" ), "test1@example.com", ) frappe.set_user("test2@example.com") - note = make_note(dict(public=1)) + note = _make_test_record(public=1) # check if auto assigned to doc owner, test2@example.com self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "owner" + "ToDo", dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), "owner" ), "test2@example.com", ) @@ -135,21 +141,23 @@ class TestAutoAssign(FrappeTestCase): def test_assign_condition(self): # check condition - note = make_note(dict(public=0)) + note = _make_test_record(public=0) self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), + "allocated_to", ), None, ) def test_clear_assignment(self): - note = make_note(dict(public=1)) + note = _make_test_record(public=1) # check if auto assigned to first user todo = frappe.get_list( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), limit=1 + "ToDo", dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), limit=1 )[0] todo = frappe.get_doc("ToDo", todo["name"]) @@ -165,11 +173,11 @@ class TestAutoAssign(FrappeTestCase): self.assertEqual(todo.status, "Cancelled") def test_close_assignment(self): - note = make_note(dict(public=1, content="valid")) + note = _make_test_record(public=1, content="valid") # check if auto assigned todo = frappe.get_list( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), limit=1 + "ToDo", dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), limit=1 )[0] todo = frappe.get_doc("ToDo", todo["name"]) @@ -186,12 +194,14 @@ class TestAutoAssign(FrappeTestCase): self.assertEqual(todo.allocated_to, "test@example.com") def check_multiple_rules(self): - note = make_note(dict(public=1, notify_on_login=1)) + note = _make_test_record(public=1, notify_on_login=1) # check if auto assigned to test3 (2nd rule is applied, as it has higher priority) self.assertEqual( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), + "allocated_to", ), "test@example.com", ) @@ -206,21 +216,25 @@ class TestAutoAssign(FrappeTestCase): get_assignment_rule([days_1, days_2], ["public == 1", "public == 1"]) frappe.flags.assignment_day = "Monday" - note = make_note(dict(public=1)) + note = _make_test_record(public=1) self.assertIn( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), + "allocated_to", ), ["test@example.com", "test1@example.com", "test2@example.com"], ) frappe.flags.assignment_day = "Friday" - note = make_note(dict(public=1)) + note = _make_test_record(public=1) self.assertIn( frappe.db.get_value( - "ToDo", dict(reference_type="Note", reference_name=note.name, status="Open"), "allocated_to" + "ToDo", + dict(reference_type=TEST_DOCTYPE, reference_name=note.name, status="Open"), + "allocated_to", ), ["test3@example.com"], ) @@ -228,17 +242,11 @@ class TestAutoAssign(FrappeTestCase): def test_assignment_rule_condition(self): frappe.db.delete("Assignment Rule") - # Add expiry_date custom field - from frappe.custom.doctype.custom_field.custom_field import create_custom_field - - df = dict(fieldname="expiry_date", label="Expiry Date", fieldtype="Date") - create_custom_field("Note", df) - assignment_rule = frappe.get_doc( dict( name="Assignment with Due Date", doctype="Assignment Rule", - document_type="Note", + document_type=TEST_DOCTYPE, assign_condition="public == 0", due_date_based_on="expiry_date", assignment_days=self.days, @@ -249,11 +257,11 @@ class TestAutoAssign(FrappeTestCase): ).insert() expiry_date = frappe.utils.add_days(frappe.utils.nowdate(), 2) - note1 = make_note({"expiry_date": expiry_date}) - note2 = make_note({"expiry_date": expiry_date}) + note1 = _make_test_record(expiry_date=expiry_date) + note2 = _make_test_record(expiry_date=expiry_date) note1_todo = frappe.get_all( - "ToDo", filters=dict(reference_type="Note", reference_name=note1.name, status="Open") + "ToDo", filters=dict(reference_type=TEST_DOCTYPE, reference_name=note1.name, status="Open") )[0] note1_todo_doc = frappe.get_doc("ToDo", note1_todo.name) @@ -268,7 +276,7 @@ class TestAutoAssign(FrappeTestCase): # saving one note's expiry should not update other note todo's due date note2_todo = frappe.get_all( "ToDo", - filters=dict(reference_type="Note", reference_name=note2.name, status="Open"), + filters=dict(reference_type=TEST_DOCTYPE, reference_name=note2.name, status="Open"), fields=["name", "date"], )[0] self.assertNotEqual(frappe.utils.get_date_str(note2_todo.date), note1.expiry_date) @@ -278,21 +286,21 @@ class TestAutoAssign(FrappeTestCase): def clear_assignments(): - frappe.db.delete("ToDo", {"reference_type": "Note"}) + frappe.db.delete("ToDo", {"reference_type": TEST_DOCTYPE}) def get_assignment_rule(days, assign=None): - frappe.delete_doc_if_exists("Assignment Rule", "For Note 1") + frappe.delete_doc_if_exists("Assignment Rule", f"For {TEST_DOCTYPE} 1") if not assign: assign = ["public == 1", "notify_on_login == 1"] assignment_rule = frappe.get_doc( dict( - name="For Note 1", + name=f"For {TEST_DOCTYPE} 1", doctype="Assignment Rule", priority=0, - document_type="Note", + document_type=TEST_DOCTYPE, assign_condition=assign[0], unassign_condition="public == 0 or notify_on_login == 1", close_condition='"Closed" in content', @@ -306,15 +314,15 @@ def get_assignment_rule(days, assign=None): ) ).insert() - frappe.delete_doc_if_exists("Assignment Rule", "For Note 2") + frappe.delete_doc_if_exists("Assignment Rule", f"For {TEST_DOCTYPE} 2") # 2nd rule frappe.get_doc( dict( - name="For Note 2", + name=f"For {TEST_DOCTYPE} 2", doctype="Assignment Rule", priority=1, - document_type="Note", + document_type=TEST_DOCTYPE, assign_condition=assign[1], unassign_condition="notify_on_login == 0", rule="Round Robin", @@ -326,12 +334,47 @@ def get_assignment_rule(days, assign=None): return assignment_rule -def make_note(values=None): - note = frappe.get_doc(dict(doctype="Note", title=random_string(10), content=random_string(20))) +def _make_test_record(**kwargs): + doc = frappe.new_doc(TEST_DOCTYPE) - if values: - note.update(values) + if kwargs: + doc.update(kwargs) - note.insert() + return doc.insert() - return note + +def create_test_doctype(doctype): + """Create custom doctype.""" + if frappe.db.exists("DocType", doctype): + return + + frappe.get_doc( + { + "doctype": "DocType", + "name": doctype, + "module": "Custom", + "custom": 1, + "fields": [ + { + "fieldname": "expiry_date", + "label": "Expiry Date", + "fieldtype": "Date", + }, + { + "fieldname": "notify_on_login", + "label": "Notify on Login", + "fieldtype": "Check", + }, + { + "fieldname": "public", + "label": "Public", + "fieldtype": "Check", + }, + { + "fieldname": "content", + "label": "Content", + "fieldtype": "Text", + }, + ], + } + ).insert() diff --git a/frappe/tests/test_assign.py b/frappe/tests/test_assign.py index f3b579c028..4243bd080a 100644 --- a/frappe/tests/test_assign.py +++ b/frappe/tests/test_assign.py @@ -2,13 +2,22 @@ # License: MIT. See LICENSE import frappe import frappe.desk.form.assign_to -from frappe.automation.doctype.assignment_rule.test_assignment_rule import make_note +from frappe.automation.doctype.assignment_rule.test_assignment_rule import ( + TEST_DOCTYPE, + _make_test_record, + create_test_doctype, +) from frappe.desk.form.load import get_assignments from frappe.desk.listview import get_group_by_count from frappe.tests.utils import FrappeTestCase class TestAssign(FrappeTestCase): + @classmethod + def setUpClass(cls): + super().setUpClass() + create_test_doctype(TEST_DOCTYPE) + def test_assign(self): todo = frappe.get_doc({"doctype": "ToDo", "description": "test"}).insert() if not frappe.db.exists("User", "test@example.com"): @@ -18,7 +27,7 @@ class TestAssign(FrappeTestCase): self.assertTrue("test@example.com" in [d.owner for d in added]) - removed = frappe.desk.form.assign_to.remove(todo.doctype, todo.name, "test@example.com") + frappe.desk.form.assign_to.remove(todo.doctype, todo.name, "test@example.com") # assignment is cleared assignments = frappe.desk.form.assign_to.get(dict(doctype=todo.doctype, name=todo.name)) @@ -47,25 +56,27 @@ class TestAssign(FrappeTestCase): } ).insert() - note = make_note() + note = _make_test_record() assign(note, "test_assign1@example.com") - note = make_note(dict(public=1)) + note = _make_test_record(public=1) assign(note, "test_assign2@example.com") - note = make_note(dict(public=1)) + note = _make_test_record(public=1) assign(note, "test_assign2@example.com") - note = make_note() + note = _make_test_record() assign(note, "test_assign2@example.com") - data = {d.name: d.count for d in get_group_by_count("Note", "[]", "assigned_to")} + data = {d.name: d.count for d in get_group_by_count(TEST_DOCTYPE, "[]", "assigned_to")} self.assertTrue("test_assign1@example.com" in data) self.assertEqual(data["test_assign1@example.com"], 1) self.assertEqual(data["test_assign2@example.com"], 3) - data = {d.name: d.count for d in get_group_by_count("Note", '[{"public": 1}]', "assigned_to")} + data = { + d.name: d.count for d in get_group_by_count(TEST_DOCTYPE, '[{"public": 1}]', "assigned_to") + } self.assertFalse("test_assign1@example.com" in data) self.assertEqual(data["test_assign2@example.com"], 2)