vassili/seitime-frappe
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

refactor: make test for assignment independent of Note

Browse source
This commit is contained in:
barredterra 2022-12-20 16:30:11 +01:00
parent 3afdb39372
commit d0f75363a5
2 changed files with 120 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

159
frappe/automation/doctype/assignment_rule/test_assignment_rule.py
View file

@ -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()

27
frappe/tests/test_assign.py
View file

@ -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)