def test_make_new_role_profile(self):
frappe.delete_doc_if_exists('Role Profile', 'Test 1', force=1)
new_role_profile = frappe.get_doc(dict(doctype='Role Profile', role_profile='Test 1')).insert()
self.assertEqual(new_role_profile.role_profile, 'Test 1')
# add role
new_role_profile.append("roles", {
"role": '_Test Role 2'
})
new_role_profile.save()
self.assertEqual(new_role_profile.roles[0].role, '_Test Role 2')
# user with a role profile
random_user = frappe.mock("email")
random_user_name = frappe.mock("name")
random_user = frappe.get_doc({
"doctype": "User",
"email": random_user,
"enabled": 1,
"first_name": random_user_name,
"new_password": "******",
"role_profile_name": 'Test 1'
}).insert(ignore_permissions=True, ignore_if_duplicate=True)
self.assertListEqual([role.role for role in random_user.roles], [role.role for role in new_role_profile.roles])
# clear roles
new_role_profile.roles = []
new_role_profile.save()
self.assertEqual(new_role_profile.roles, [])
# user roles with the role profile should also be updated
random_user.reload()
self.assertListEqual(random_user.roles, [])
def setUpClass(self):
for _ in range(10):
doc = frappe.get_doc({
"doctype": "ToDo",
"description": frappe.mock("paragraph")
}).insert()
self.GENERATED_DOCUMENTS.append(doc.name)
def test_create_document(self):
# test 7: POST method on /api/resource to create doc
data = {"description": frappe.mock("paragraph")}
response = self.post(self.DOCTYPE, data)
self.assertEqual(response.status_code, 200)
docname = response.json()["data"]["name"]
self.assertIsInstance(docname, str)
self.GENERATED_DOCUMENTS.append(docname)
def test_signup(self):
import frappe.website.utils
random_user = frappe.mock("email")
random_user_name = frappe.mock("name")
# disabled signup
with patch.object(user_module, "is_signup_disabled", return_value=True):
self.assertRaisesRegex(
frappe.exceptions.ValidationError,
"Sign Up is disabled",
sign_up,
random_user,
random_user_name,
"/signup",
)
self.assertTupleEqual(
sign_up(random_user, random_user_name, "/welcome"),
(1, "Please check your email for verification"),
)
self.assertEqual(frappe.cache().hget("redirect_after_login", random_user), "/welcome")
# re-register
self.assertTupleEqual(
sign_up(random_user, random_user_name, "/welcome"), (0, "Already Registered")
)
# disabled user
user = frappe.get_doc("User", random_user)
user.enabled = 0
user.save()
self.assertTupleEqual(
sign_up(random_user, random_user_name, "/welcome"), (0, "Registered but disabled")
)
# throttle user creation
with patch.object(user_module.frappe.db, "get_creation_count", return_value=301):
self.assertRaisesRegex(
frappe.exceptions.ValidationError,
"Throttled",
sign_up,
frappe.mock("email"),
random_user_name,
"/signup",
)
def setUp(self):
# retrieve or create a User webhook for `after_insert`
webhook_fields = {
"webhook_doctype": "User",
"webhook_docevent": "after_insert",
"request_url": "https://httpbin.org/post"
}
if frappe.db.exists("Webhook", webhook_fields):
self.webhook = frappe.get_doc("Webhook", webhook_fields)
else:
self.webhook = frappe.new_doc("Webhook")
self.webhook.update(webhook_fields)
# create a User document
self.user = frappe.new_doc("User")
self.user.first_name = frappe.mock("name")
self.user.email = frappe.mock("email")
self.user.save()
def test_update_document(self):
# test 8: PUT method on /api/resource to update doc
generated_desc = frappe.mock("paragraph")
data = {"description": generated_desc}
random_doc = choice(self.GENERATED_DOCUMENTS)
desc_before_update = frappe.db.get_value(self.DOCTYPE, random_doc,
"description")
response = self.put(f"{self.DOCTYPE}/{random_doc}", data=data)
self.assertEqual(response.status_code, 200)
self.assertNotEqual(response.json()["data"]["description"],
desc_before_update)
self.assertEqual(response.json()["data"]["description"],
generated_desc)
def test_send_newsletter_with_attachments(self):
newsletter = self.get_newsletter()
newsletter.reload()
file_attachment = frappe.get_doc({
"doctype": "File",
"file_name": "test1.txt",
"attached_to_doctype": newsletter.doctype,
"attached_to_name": newsletter.name,
"content": frappe.mock("paragraph")
})
file_attachment.save()
newsletter.send_attachments = True
newsletter_attachments = newsletter.get_newsletter_attachments()
self.assertEqual(len(newsletter_attachments), 1)
self.assertEqual(newsletter_attachments[0]["fid"], file_attachment.name)
def setUp(self):
# retrieve or create a User webhook for `after_insert`
webhook_fields = {
"webhook_doctype": "User",
"webhook_docevent": "after_insert",
"request_url": "https://httpbin.org/post",
}
if frappe.db.exists("Webhook", webhook_fields):
self.webhook = frappe.get_doc("Webhook", webhook_fields)
else:
self.webhook = frappe.new_doc("Webhook")
self.webhook.update(webhook_fields)
# create a User document
self.user = frappe.new_doc("User")
self.user.first_name = frappe.mock("name")
self.user.email = frappe.mock("email")
self.user.save()
# Create another test user specific to this test
self.test_user = frappe.new_doc("User")
self.test_user.email = "*****@*****.**"
self.test_user.first_name = "user1"
def test_partial_restore(self):
_now = now()
for num in range(10):
frappe.get_doc({
"doctype": "ToDo",
"date": add_to_date(_now, days=num),
"description": frappe.mock("paragraph")
}).insert()
frappe.db.commit()
todo_count = frappe.db.count("ToDo")
# check if todos exist, create a partial backup and see if the state is the same after restore
self.assertIsNot(todo_count, 0)
self.execute("bench --site {site} backup --only 'ToDo'")
db_path = fetch_latest_backups(partial=True)["database"]
self.assertTrue("partial" in db_path)
frappe.db.sql_ddl("DROP TABLE IF EXISTS `tabToDo`")
frappe.db.commit()
self.execute("bench --site {site} partial-restore {path}", {"path": db_path})
self.assertEquals(self.returncode, 0)
self.assertEquals(frappe.db.count("ToDo"), todo_count)
