def test_insert_if_owner_with_user_permissions(self): """If `If Owner` is checked for a Role, check if that document is allowed to be read, updated, submitted, etc. except be created, even if the document is restricted based on User Permissions.""" self.set_user_permission_doctypes(["Blog Category"]) self.if_owner_setup() frappe.set_user("*****@*****.**") doc = frappe.get_doc({ "doctype": "Blog Post", "blog_category": "_Test Blog Category", "blogger": "_Test Blogger 1", "title": "_Test Blog Post Title", "content": "_Test Blog Post Content" }) self.assertRaises(frappe.PermissionError, doc.insert) frappe.set_user("Administrator") frappe.permissions.add_user_permission("Blog Category", "_Test Blog Category", "*****@*****.**") frappe.set_user("*****@*****.**") doc.insert() frappe.set_user("Administrator") frappe.permissions.remove_user_permission("Blog Category", "_Test Blog Category", "*****@*****.**") frappe.set_user("*****@*****.**") doc = frappe.get_doc(doc.doctype, doc.name) self.assertTrue(doc.has_permission("read")) self.assertTrue(doc.has_permission("write")) self.assertFalse(doc.has_permission("create"))
def work(): frappe.set_user(frappe.db.get_global('demo_manufacturing_user')) make_purchase_receipt() make_delivery_note() make_stock_reconciliation() submit_draft_stock_entries()
def run_async_task(self, site=None, user=None, cmd=None, form_dict=None, hijack_std=False): ret = {} frappe.init(site) frappe.connect() frappe.local.task_id = self.request.id if hijack_std: original_stdout, original_stderr = sys.stdout, sys.stderr sys.stdout, sys.stderr = get_std_streams(self.request.id) frappe.local.stdout, frappe.local.stderr = sys.stdout, sys.stderr try: set_task_status(self.request.id, "Running") frappe.db.commit() frappe.set_user(user) # sleep(60) frappe.local.form_dict = frappe._dict(form_dict) execute_cmd(cmd, from_async=True) ret = frappe.local.response except Exception, e: frappe.db.rollback() ret = frappe.local.response http_status_code = getattr(e, "http_status_code", 500) ret['status_code'] = http_status_code frappe.errprint(frappe.get_traceback()) frappe.utils.response.make_logs() set_task_status(self.request.id, "Error", response=ret) task_logger.error('Exception in running {}: {}'.format(cmd, ret['exc']))
def tearDown(self): frappe.set_user("Administrator") set_perpetual_inventory(0) for role in ("Stock User", "Sales User"): set_user_permission_doctypes(doctype="Stock Entry", role=role, apply_user_permissions=0, user_permission_doctypes=None)
def test_warehouse_user(self): set_perpetual_inventory(0) for role in ("Stock User", "Sales User"): set_user_permission_doctypes(doctype="Stock Entry", role=role, apply_user_permissions=1, user_permission_doctypes=["Warehouse"]) frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", "User Permission") frappe.defaults.add_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", "User Permission") test_user = frappe.get_doc("User", "*****@*****.**") test_user.add_roles("Sales User", "Sales Manager", "Stock User") test_user.remove_roles("Stock Manager") frappe.get_doc("User", "*****@*****.**")\ .add_roles("Sales User", "Sales Manager", "Stock User", "Stock Manager") frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("items")[0].t_warehouse="_Test Warehouse 2 - _TC1" self.assertRaises(frappe.PermissionError, st1.insert) frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("items")[0].t_warehouse="_Test Warehouse 2 - _TC1" st1.insert() st1.submit() frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", parenttype="User Permission") frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", parenttype="User Permission")
def test_if_user_is_added(self): ev = frappe.get_doc({ 'doctype': 'Event', 'subject': 'test event for view logs', 'starts_on': '2018-06-04 14:11:00', 'event_type': 'Public' }).insert() frappe.set_user('*****@*****.**') from frappe.desk.form.load import getdoc # load the form getdoc('Event', ev.name) a = frappe.get_value( doctype="View Log", filters={ "reference_doctype": "Event", "reference_name": ev.name }, fieldname=['viewed_by'] ) self.assertEqual('*****@*****.**', a) self.assertNotEqual('*****@*****.**', a)
def x_render_page(path): log("-- on render_page(%s)" % path) try: filepath, ext = os.path.splitext(path) # we only care about pages if ext not in [".js", ".css"]: user = frappe.get_user() if user.name == "Guest": email = random_string(20) + "@guest.local" user = frappe.get_doc({ "doctype": "User", "email": email, "first_name": "Guest User", "enabled": 1, "new_password": random_string(10), "user_type": "Website User" }) user.flags.ignore_permissions = True user.insert() frappe.local.login_manager.login_as(user.name) frappe.set_user(user.name) log("USER: %s" % user.name) result = x_render_page.patched_method(path) except Exception as ex: log(traceback.format_exc()) raise ex #log(result[0:40] + "...") return result
def test_overlap_with_half_day_3(self): self._clear_roles() self._clear_applications() from frappe.utils.user import add_role add_role("*****@*****.**", "Employee") frappe.set_user("*****@*****.**") make_allocation_record() # leave from 1-5, half day on 5th application = self.get_application(_test_records[0]) application.half_day = 1 application.half_day_date = "2013-01-05" application.insert() # Apply leave from 4-7, half day on 5th application = self.get_application(_test_records[0]) application.from_date = "2013-01-04" application.to_date = "2013-01-07" application.half_day = 1 application.half_day_date = "2013-01-05" self.assertRaises(OverlapError, application.insert) # Apply leave from 5-7, half day on 5th application = self.get_application(_test_records[0]) application.from_date = "2013-01-05" application.to_date = "2013-01-07" application.half_day = 1 application.half_day_date = "2013-01-05" application.insert()
def test_overlap_with_half_day(self): self._clear_roles() self._clear_applications() from frappe.utils.user import add_role add_role("*****@*****.**", "Employee") add_role("*****@*****.**", "Leave Approver") frappe.set_user("*****@*****.**") make_allocation_record() # allow second half-day on the same day if available application = self.get_application(_test_records[0]) application.leave_approver = "*****@*****.**" application.half_day = 1 application.insert() # allow second half-day on the same day if available application = self.get_application(_test_records[0]) application.leave_approver = "*****@*****.**" application.half_day = 1 application.insert() application = self.get_application(_test_records[0]) application.leave_approver = "*****@*****.**" application.half_day = 1 self.assertRaises(OverlapError, application.insert)
def test_warehouse_user(self): for role in ("Stock User", "Sales User"): set_user_permission_doctypes(doctype="Sales Order", role=role, apply_user_permissions=1, user_permission_doctypes=["Warehouse"]) frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**") frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**") frappe.permissions.add_user_permission("Company", "_Test Company 1", "*****@*****.**") test_user = frappe.get_doc("User", "*****@*****.**") test_user.add_roles("Sales User", "Stock User") test_user.remove_roles("Sales Manager") test_user_2 = frappe.get_doc("User", "*****@*****.**") test_user_2.add_roles("Sales User", "Stock User") test_user_2.remove_roles("Sales Manager") frappe.set_user("*****@*****.**") so = make_sales_order(company="_Test Company 1", warehouse="_Test Warehouse 2 - _TC1", do_not_save=True) so.conversion_rate = 0.02 so.plc_conversion_rate = 0.02 self.assertRaises(frappe.PermissionError, so.insert) frappe.set_user("*****@*****.**") so.insert() frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**") frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**") frappe.permissions.remove_user_permission("Company", "_Test Company 1", "*****@*****.**")
def tearDown(self): frappe.set_user("Administrator") for role in ("Stock User", "Sales User"): set_user_permission_doctypes( doctype="Sales Order", role=role, apply_user_permissions=0, user_permission_doctypes=None )
def send(self): # send email only to enabled users valid_users = [ p[0] for p in frappe.db.sql( """select name from `tabUser` where enabled=1""" ) ] recipients = filter(lambda r: r in valid_users, self.recipient_list.split("\n")) original_user = frappe.session.user if recipients: for user_id in recipients: frappe.set_user(user_id) msg_for_this_receipient = self.get_msg_html() if msg_for_this_receipient: frappe.sendmail( recipients=user_id, subject="{frequency} Digest".format(frequency=self.frequency), message=msg_for_this_receipient, bulk=True, reference_doctype=self.doctype, reference_name=self.name, unsubscribe_message=_("Unsubscribe from this Email Digest"), ) frappe.set_user(original_user)
def test_build_match_conditions(self): clear_user_permissions_for_doctype('Blog Post', '*****@*****.**') test2user = frappe.get_doc('User', '*****@*****.**') test2user.add_roles('Blogger') frappe.set_user('*****@*****.**') # this will get match conditions for Blog Post build_match_conditions = DatabaseQuery('Blog Post').build_match_conditions # Before any user permission is applied # get as filters self.assertEqual(build_match_conditions(as_condition=False), []) # get as conditions self.assertEqual(build_match_conditions(as_condition=True), "") add_user_permission('Blog Post', '-test-blog-post', '*****@*****.**', True) add_user_permission('Blog Post', '-test-blog-post-1', '*****@*****.**', True) # After applying user permission # get as filters self.assertTrue({'Blog Post': ['-test-blog-post-1', '-test-blog-post']} in build_match_conditions(as_condition=False)) # get as conditions self.assertEqual(build_match_conditions(as_condition=True), """(((ifnull(`tabBlog Post`.`name`, "")="" or `tabBlog Post`.`name` in ("-test-blog-post-1", "-test-blog-post"))))""") frappe.set_user('Administrator')
def test_warehouse_user(self): set_perpetual_inventory(0) frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", "User Permission") frappe.defaults.add_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", "User Permission") test_user = frappe.get_doc("User", "*****@*****.**") test_user.add_roles("Sales User", "Sales Manager", "Material User") test_user.remove_roles("Material Manager") frappe.get_doc("User", "*****@*****.**")\ .add_roles("Sales User", "Sales Manager", "Material User", "Material Manager") frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("mtn_details")[0].t_warehouse="_Test Warehouse 2 - _TC1" self.assertRaises(frappe.PermissionError, st1.insert) frappe.set_user("*****@*****.**") st1 = frappe.copy_doc(test_records[0]) st1.company = "_Test Company 1" st1.get("mtn_details")[0].t_warehouse="_Test Warehouse 2 - _TC1" st1.insert() st1.submit() frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", parenttype="User Permission") frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", parenttype="User Permission")
def test_warehouse_user(self): frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**") frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**") frappe.permissions.add_user_permission("Company", "_Test Company 1", "*****@*****.**") test_user = frappe.get_doc("User", "*****@*****.**") test_user.add_roles("Sales User", "Material User") test_user.remove_roles("Sales Manager") test_user_2 = frappe.get_doc("User", "*****@*****.**") test_user_2.add_roles("Sales User", "Material User") test_user_2.remove_roles("Sales Manager") frappe.set_user("*****@*****.**") so = frappe.copy_doc(test_records[0]) so.company = "_Test Company 1" so.conversion_rate = 0.02 so.plc_conversion_rate = 0.02 so.get("sales_order_details")[0].warehouse = "_Test Warehouse 2 - _TC1" self.assertRaises(frappe.PermissionError, so.insert) frappe.set_user("*****@*****.**") so.insert() frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**") frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**") frappe.permissions.remove_user_permission("Company", "_Test Company 1", "*****@*****.**")
def test_clear_user_permissions(self): current_user = frappe.session.user frappe.set_user('Administrator') clear_user_permissions_for_doctype('Blog Category', '*****@*****.**') clear_user_permissions_for_doctype('Blog Post', '*****@*****.**') add_user_permission('Blog Post', '-test-blog-post-1', '*****@*****.**') add_user_permission('Blog Post', '-test-blog-post-2', '*****@*****.**') add_user_permission("Blog Category", '_Test Blog Category 1', '*****@*****.**') deleted_user_permission_count = clear_user_permissions('*****@*****.**', 'Blog Post') self.assertEqual(deleted_user_permission_count, 2) blog_post_user_permission_count = frappe.db.count('User Permission', filters={ 'user': '******', 'allow': 'Blog Post' }) self.assertEqual(blog_post_user_permission_count, 0) blog_category_user_permission_count = frappe.db.count('User Permission', filters={ 'user': '******', 'allow': 'Blog Category' }) self.assertEqual(blog_category_user_permission_count, 1) # reset the user frappe.set_user(current_user)
def tearDown(self): frappe.set_user("Administrator") frappe.db.set_value("Blogger", "_Test Blogger 1", "user", None) clear_user_permissions_for_doctype("Blog Category") clear_user_permissions_for_doctype("Blog Post") clear_user_permissions_for_doctype("Blogger")
def test_employee_salary_slip_read_permission(self): self.make_employee("*****@*****.**") salary_slip_test_employee = frappe.get_doc("Salary Slip", self.make_employee_salary_slip("*****@*****.**", "Monthly")) frappe.set_user("*****@*****.**") self.assertTrue(salary_slip_test_employee.has_permission("read"))
def test_global_block_list(self): self._clear_roles() from frappe.utils.user import add_role add_role("*****@*****.**", "Employee") add_role("*****@*****.**", "Leave Approver") self._add_employee_leave_approver("_T-Employee-0002", "*****@*****.**") make_allocation_record(employee="_T-Employee-0002") application = self.get_application(_test_records[1]) application.leave_approver = "*****@*****.**" frappe.db.set_value("Leave Block List", "_Test Leave Block List", "applies_to_all_departments", 1) frappe.db.set_value("Employee", "_T-Employee-0002", "department", "_Test Department") frappe.set_user("*****@*****.**") application.insert() frappe.set_user("*****@*****.**") application.status = "Approved" self.assertRaises(LeaveDayBlockedError, application.submit) frappe.db.set_value("Leave Block List", "_Test Leave Block List", "applies_to_all_departments", 0)
def _test_leave_approval_valid_leave_approver_insert(self): self._clear_applications() self._add_employee_leave_approver("_T-Employee-0001", "*****@*****.**") original_department = frappe.db.get_value("Employee", "_T-Employee-0001", "department") frappe.db.set_value("Employee", "_T-Employee-0001", "department", None) frappe.set_user("*****@*****.**") make_allocation_record() application = self.get_application(_test_records[0]) application.leave_approver = "*****@*****.**" application.insert() # change to valid leave approver and try to submit leave application frappe.set_user("*****@*****.**") application.status = "Approved" application.submit() self.assertEqual(frappe.db.get_value("Leave Application", application.name, "docstatus"), 1) frappe.db.sql("""delete from `tabEmployee Leave Approver` where parent=%s""", "_T-Employee-0001") frappe.db.set_value("Employee", "_T-Employee-0001", "department", original_department)
def test_alert_disabled_on_wrong_field(self): frappe.set_user('Administrator') email_alert = frappe.get_doc({ "doctype": "Email Alert", "subject":"_Test Email Alert for wrong field", "document_type": "Event", "event": "Value Change", "attach_print": 0, "value_changed": "description1", "message": "Description changed", "recipients": [ { "email_by_document_field": "owner" } ] }).insert() event = frappe.new_doc("Event") event.subject = "test-2", event.event_type = "Private" event.starts_on = "2014-06-06 12:00:00" event.insert() event.subject = "test 1" event.save() # verify that email_alert is disabled email_alert.reload() self.assertEqual(email_alert.enabled, 0) email_alert.delete() event.delete()
def update_shopify_settings(shop, session, site_name, email): frappe.set_user("Administrator") shopify_user = frappe.db.sql("""select name from `tabShopify User` where shop_name = %s order by creation desc limit 1""", shop, as_list=1)[0][0] shopify_user = update_broker_info(shopify_user, email, site_name) url = "https://{}/api/resource/Shopify Settings/Shopify Settings".format(shopify_user.site_name) data = { "access_token": shopify_user.access_token, "shopify_url": shop, "app_type": "Public" } res = session.put(url, data='data='+json.dumps(data), headers={'content-type': 'application/x-www-form-urlencoded'}) if res.status_code == 200: url = "https://{}/api/method/logout".format(shopify_user.site_name) res = session.get(url) return {"redirect": "https://{}/admin/apps".format(shop)} else: return {"error": _("Something went wrong. Please try again.")}
def test_date_changed(self): event = frappe.new_doc("Event") event.subject = "test", event.event_type = "Private" event.starts_on = "2014-01-01 12:00:00" event.insert() self.assertFalse(frappe.db.get_value("Email Queue", {"reference_doctype": "Event", "reference_name": event.name, "status":"Not Sent"})) frappe.set_user('Administrator') frappe.utils.scheduler.trigger(frappe.local.site, "daily", now=True) # not today, so no alert self.assertFalse(frappe.db.get_value("Email Queue", {"reference_doctype": "Event", "reference_name": event.name, "status":"Not Sent"})) event.starts_on = frappe.utils.add_days(frappe.utils.nowdate(), 2) + " 12:00:00" event.save() # Value Change email alert alert will be trigger as description is not changed # mail will not be sent self.assertFalse(frappe.db.get_value("Email Queue", {"reference_doctype": "Event", "reference_name": event.name, "status":"Not Sent"})) frappe.utils.scheduler.trigger(frappe.local.site, "daily", now=True) # today so show alert self.assertTrue(frappe.db.get_value("Email Queue", {"reference_doctype": "Event", "reference_name": event.name, "status":"Not Sent"}))
def make(): #frappe.flags.print_messages = True frappe.flags.mute_emails = True setup() frappe.set_user("Administrator") frappe.flags.rollback_on_exception = True simulate()
def test_strict_user_permissions(self): """If `Strict User Permissions` is checked in System Settings, show records even if User Permissions are missing for a linked doctype""" frappe.set_user("Administrator") frappe.db.sql('delete from tabContact') make_test_records_for_doctype('Contact', force=True) set_user_permission_doctypes("Contact", role="Sales User", apply_user_permissions=1, user_permission_doctypes=['Salutation']) set_user_permission_doctypes("Salutation", role="All", apply_user_permissions=1, user_permission_doctypes=['Salutation']) add_user_permission("Salutation", "Mr", "*****@*****.**") self.set_strict_user_permissions(0) frappe.set_user("*****@*****.**") self.assertEquals(len(frappe.get_list("Contact")), 2) frappe.set_user("Administrator") self.set_strict_user_permissions(1) frappe.set_user("*****@*****.**") self.assertTrue(len(frappe.get_list("Contact")), 1) frappe.set_user("Administrator") self.set_strict_user_permissions(0)
def work(): frappe.set_user(frappe.db.get_global('demo_sales_user_2')) if random.random() < 0.5: for i in xrange(random.randint(1,7)): make_opportunity() if random.random() < 0.5: for i in xrange(random.randint(1,3)): make_quotation() # lost quotations / inquiries if random.random() < 0.3: for i in xrange(random.randint(1,3)): quotation = get_random('Quotation', doc=True) if quotation and quotation.status == 'Submitted': quotation.declare_order_lost('Did not ask') for i in xrange(random.randint(1,3)): opportunity = get_random('Opportunity', doc=True) if opportunity and opportunity.status in ('Open', 'Replied'): opportunity.declare_enquiry_lost('Did not ask') if random.random() < 0.3: for i in xrange(random.randint(1,3)): make_sales_order()
def run_async_task(self, site, user, cmd, form_dict): ret = {} frappe.init(site) frappe.connect() sys.stdout, sys.stderr = get_std_streams(self.request.id) frappe.local.stdout, frappe.local.stderr = sys.stdout, sys.stderr frappe.local.task_id = self.request.id frappe.cache() try: set_task_status(self.request.id, "Running") frappe.db.commit() frappe.set_user(user) # sleep(60) frappe.local.form_dict = frappe._dict(form_dict) execute_cmd(cmd, from_async=True) ret = frappe.local.response except Exception, e: frappe.db.rollback() if not frappe.flags.in_test: frappe.db.commit() ret = frappe.local.response http_status_code = getattr(e, "http_status_code", 500) ret['status_code'] = http_status_code frappe.errprint(frappe.get_traceback()) frappe.utils.response.make_logs() set_task_status(self.request.id, "Failed", response=ret) task_logger.error('Exception in running {}: {}'.format(cmd, ret['exc']))
def test_block_list(self): self._clear_roles() from frappe.utils.user import add_role add_role("*****@*****.**", "HR User") add_role("*****@*****.**", "Leave Approver") clear_user_permissions_for_doctype("Employee") frappe.db.set_value("Department", "_Test Department", "leave_block_list", "_Test Leave Block List") make_allocation_record() application = self.get_application(_test_records[0]) application.insert() application.status = "Approved" self.assertRaises(LeaveDayBlockedError, application.submit) frappe.set_user("*****@*****.**") # clear other applications frappe.db.sql("delete from `tabLeave Application`") application = self.get_application(_test_records[0]) self.assertTrue(application.insert())
def test_event_list(self): frappe.set_user("*****@*****.**") res = frappe.get_list("Event", filters=[["Event", "subject", "like", "_Test Event%"]], fields=["name", "subject"]) self.assertEquals(len(res), 2) subjects = [r.subject for r in res] self.assertTrue("_Test Event 1" in subjects) self.assertTrue("_Test Event 3" in subjects) self.assertFalse("_Test Event 2" in subjects)
def set_as_paid(self): if frappe.session.user == "Guest": frappe.set_user("Administrator") payment_entry = self.create_payment_entry() self.make_invoice() return payment_entry
def login_as_new_user(self): self.create_user_if_not_exists("*****@*****.**") frappe.set_user("*****@*****.**")
def login_as_customer( self, email="*****@*****.**", name="_Test Contact For _Test Customer" ): self.create_user_if_not_exists(email, name) frappe.set_user(email)
def tearDown(self): frappe.db.rollback() frappe.set_user("Administrator") self.disable_shopping_cart()
def setUp(self): frappe.set_user("Administrator") create_test_data()
def tearDown(self): frappe.set_user("Administrator") delete_test_data()
def test_date_changed(self): event = frappe.new_doc("Event") event.subject = "test", event.event_type = "Private" event.starts_on = "2014-01-01 12:00:00" event.insert() self.assertFalse( frappe.db.get_value( "Email Queue", { "reference_doctype": "Event", "reference_name": event.name, "status": "Not Sent" })) frappe.set_user('Administrator') frappe.get_doc( 'Scheduled Job Type', dict( method= 'frappe.email.doctype.notification.notification.trigger_daily_alerts' )).execute() # not today, so no alert self.assertFalse( frappe.db.get_value( "Email Queue", { "reference_doctype": "Event", "reference_name": event.name, "status": "Not Sent" })) event.starts_on = frappe.utils.add_days(frappe.utils.nowdate(), 2) + " 12:00:00" event.save() # Value Change notification alert will be trigger as description is not changed # mail will not be sent self.assertFalse( frappe.db.get_value( "Email Queue", { "reference_doctype": "Event", "reference_name": event.name, "status": "Not Sent" })) frappe.get_doc( 'Scheduled Job Type', dict( method= 'frappe.email.doctype.notification.notification.trigger_daily_alerts' )).execute() # today so show alert self.assertTrue( frappe.db.get_value( "Email Queue", { "reference_doctype": "Event", "reference_name": event.name, "status": "Not Sent" }))
def setUp(self): frappe.db.sql("""delete from `tabEmail Queue`""") frappe.set_user("*****@*****.**")
def tearDown(self): frappe.set_user('Administrator') frappe.db.sql('DELETE FROM `tabEnergy Point Log`') frappe.db.sql('DELETE FROM `tabEnergy Point Rule`') frappe.cache().delete_value('energy_point_rule_map')
def tearDown(self): frappe.db.set_value("HR Settings", "HR Settings", "include_holidays_in_total_working_days", 0) frappe.set_user("Administrator")
def work(): if random.random() < 0.3: return frappe.set_user(frappe.db.get_global('demo_manufacturing_user')) frappe.set_user_lang(frappe.db.get_global('demo_manufacturing_user')) if not frappe.get_all('Sales Order'): return from erpnext.projects.doctype.timesheet.timesheet import OverlapError ppt = frappe.new_doc("Production Plan") ppt.company = erpnext.get_default_company() # ppt.use_multi_level_bom = 1 #refactored ppt.get_items_from = "Sales Order" # ppt.purchase_request_for_warehouse = "Stores - WP" # refactored ppt.run_method("get_open_sales_orders") if not ppt.get("sales_orders"): return ppt.run_method("get_items") ppt.run_method("raise_material_requests") ppt.save() ppt.submit() ppt.run_method("raise_work_orders") frappe.db.commit() # submit work orders for pro in frappe.db.get_values("Work Order", {"docstatus": 0}, "name"): b = frappe.get_doc("Work Order", pro[0]) b.wip_warehouse = "Work in Progress - WP" b.submit() frappe.db.commit() # submit material requests for pro in frappe.db.get_values("Material Request", {"docstatus": 0}, "name"): b = frappe.get_doc("Material Request", pro[0]) b.submit() frappe.db.commit() # stores -> wip if random.random() < 0.4: for pro in query_report.run("Open Work Orders")[ "result"][:how_many("Stock Entry for WIP")]: make_stock_entry_from_pro(pro[0], "Material Transfer for Manufacture") # wip -> fg if random.random() < 0.4: for pro in query_report.run("Work Orders in Progress")[ "result"][:how_many("Stock Entry for FG")]: make_stock_entry_from_pro(pro[0], "Manufacture") for bom in frappe.get_all('BOM', fields=['item'], filters={'with_operations': 1}): pro_order = make_wo_order_test_record( item=bom.item, qty=2, source_warehouse=_("Stores") + " - WP", wip_warehouse=_("Work in Progress") + " - WP", fg_warehouse=_("Stores") + " - WP", company=erpnext.get_default_company(), stock_uom=frappe.db.get_value('Item', bom.item, 'stock_uom'), planned_start_date=get_datetime(frappe.flags.current_date)) # submit job card if random.random() < 0.4: submit_job_cards()
def tearDown(self): frappe.set_user("Administrator")
def test_permission(self): frappe.set_user("Guest") self.assertRaises(frappe.PermissionError, self.test_insert) frappe.set_user("Administrator")
def remove_test_quotation(self, quotation): frappe.set_user("Administrator") quotation.delete()
def tearDown(self): frappe.set_user("Administrator") # so that this test doesn't affect other tests frappe.db.sql("""delete from `tabEmployee Leave Approver`""")
def tearDown(self): frappe.set_user("Administrator") set_perpetual_inventory(0)
def test_gstr_3b_report(self): month_number_mapping = { 1: "January", 2: "February", 3: "March", 4: "April", 5: "May", 6: "June", 7: "July", 8: "August", 9: "September", 10: "October", 11: "November", 12: "December" } frappe.set_user("Administrator") frappe.db.sql( "delete from `tabSales Invoice` where company='_Test Company GST'") frappe.db.sql( "delete from `tabPurchase Invoice` where company='_Test Company GST'" ) frappe.db.sql( "delete from `tabGSTR 3B Report` where company='_Test Company GST'" ) make_company() make_item("Milk", properties={ "is_nil_exempt": 1, "standard_rate": 0.000000 }) set_account_heads() make_customers() make_suppliers() make_sales_invoice() create_purchase_invoices() if frappe.db.exists("GSTR 3B Report", "GSTR3B-March-2019-_Test Address-Billing"): report = frappe.get_doc("GSTR 3B Report", "GSTR3B-March-2019-_Test Address-Billing") report.save() else: report = frappe.get_doc({ "doctype": "GSTR 3B Report", "company": "_Test Company GST", "company_address": "_Test Address-Billing", "year": getdate().year, "month": month_number_mapping.get(getdate().month) }).insert() output = json.loads(report.json_output) self.assertEqual(output["sup_details"]["osup_det"]["iamt"], 36), self.assertEqual(output["sup_details"]["osup_zero"]["iamt"], 18), self.assertEqual(output["inter_sup"]["unreg_details"][0]["iamt"], 18), self.assertEqual(output["sup_details"]["osup_nil_exmp"]["txval"], 100), self.assertEqual(output["inward_sup"]["isup_details"][0]["inter"], 250) self.assertEqual(output["itc_elg"]["itc_avl"][4]["samt"], 22.50) self.assertEqual(output["itc_elg"]["itc_avl"][4]["camt"], 22.50)
def test_allowed_public(self): frappe.set_user("*****@*****.**") doc = frappe.get_doc( "Gate Register", frappe.db.get_value("Gate Register", {"company": "Kaynes Technology - 01"}))
def add_payments(): if frappe.flags.test_payments_created: return frappe.set_user("Administrator") try: frappe.get_doc({ "doctype": "Supplier", "supplier_group": "All Supplier Groups", "supplier_type": "Company", "supplier_name": "Conrad Electronic" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Conrad Electronic", qty=1, rate=690) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Conrad Oct 18" pe.reference_date = "2018-10-24" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Supplier", "supplier_group": "All Supplier Groups", "supplier_type": "Company", "supplier_name": "Mr G" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1200) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Herr G Oct 18" pe.reference_date = "2018-10-24" pe.insert() pe.submit() pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1700) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Herr G Nov 18" pe.reference_date = "2018-11-01" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Supplier", "supplier_group": "All Supplier Groups", "supplier_type": "Company", "supplier_name": "Poore Simon's" }).insert() except frappe.DuplicateEntryError: pass try: frappe.get_doc({ "doctype": "Customer", "customer_group": "All Customer Groups", "customer_type": "Company", "customer_name": "Poore Simon's" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Poore Simon's", qty=1, rate=3900) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Poore Simon's Oct 18" pe.reference_date = "2018-10-28" pe.insert() pe.submit() si = create_sales_invoice(customer="Poore Simon's", qty=1, rate=3900) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "Poore Simon's Oct 18" pe.reference_date = "2018-10-28" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Customer", "customer_group": "All Customer Groups", "customer_type": "Company", "customer_name": "Fayva" }).insert() except frappe.DuplicateEntryError: pass si = create_sales_invoice(customer="Fayva", qty=1, rate=109080) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "Fayva Oct 18" pe.reference_date = "2018-10-29" pe.insert() pe.submit() mode_of_payment = frappe.get_doc({ "doctype": "Mode of Payment", "name": "Cash" }) if not frappe.db.get_value('Mode of Payment Account', { 'company': "_Test Company", 'parent': "Cash" }): mode_of_payment.append("accounts", { "company": "_Test Company", "default_account": "_Test Bank - _TC" }) mode_of_payment.save() si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_submit=1) si.is_pos = 1 si.append("payments", { "mode_of_payment": "Cash", "account": "_Test Bank - _TC", "amount": 109080 }) si.save() si.submit() frappe.flags.test_payments_created = True
def tearDown(self): frappe.set_user("*****@*****.**")
def add_transactions(): if frappe.flags.test_bank_transactions_created: return frappe.set_user("Administrator") create_bank_account() doc = frappe.get_doc({ "doctype": "Bank Transaction", "description": "1512567 BG/000002918 OPSKATTUZWXXX AT776000000098709837 Herr G", "date": "2018-10-23", "debit": 1200, "currency": "INR", "bank_account": "Checking Account - Citi Bank" }).insert() doc.submit() doc = frappe.get_doc({ "doctype": "Bank Transaction", "description": "1512567 BG/000003025 OPSKATTUZWXXX AT776000000098709849 Herr G", "date": "2018-10-23", "debit": 1700, "currency": "INR", "bank_account": "Checking Account - Citi Bank" }).insert() doc.submit() doc = frappe.get_doc({ "doctype": "Bank Transaction", "description": "Re 95282925234 FE/000002917 AT171513000281183046 Conrad Electronic", "date": "2018-10-26", "debit": 690, "currency": "INR", "bank_account": "Checking Account - Citi Bank" }).insert() doc.submit() doc = frappe.get_doc({ "doctype": "Bank Transaction", "description": "Auszahlung Karte MC/000002916 AUTOMAT 698769 K002 27.10. 14:07", "date": "2018-10-27", "debit": 3900, "currency": "INR", "bank_account": "Checking Account - Citi Bank" }).insert() doc.submit() doc = frappe.get_doc({ "doctype": "Bank Transaction", "description": "I2015000011 VD/000002514 ATWWXXX AT4701345000003510057 Bio", "date": "2018-10-27", "credit": 109080, "currency": "INR", "bank_account": "Checking Account - Citi Bank" }).insert() doc.submit() frappe.flags.test_bank_transactions_created = True
def test_portal(self): self.send_newsletter(1) frappe.set_user("*****@*****.**") from frappe.email.doctype.newsletter.newsletter import get_newsletter_list newsletters = get_newsletter_list("Newsletter", None, None, 0) self.assertEquals(len(newsletters), 1)
def test_permission_single(self): frappe.set_user("Guest") d = frappe.get_doc("Website Settings", "Website Settigns") self.assertRaises(frappe.PermissionError, d.save) frappe.set_user("Administrator")
def execute_job(site, method, event, job_name, kwargs, user=None, is_async=True, retry=0): """Executes job in a worker, performs commit/rollback and logs if there is any error""" if is_async: frappe.connect(site) if os.environ.get("CI"): frappe.flags.in_test = True if user: frappe.set_user(user) if isinstance(method, string_types): method_name = method method = frappe.get_attr(method) else: method_name = cstr(method.__name__) frappe.monitor.start("job", method_name, kwargs) try: method(**kwargs) except (frappe.db.InternalError, frappe.RetryBackgroundJobError) as e: frappe.db.rollback() if retry < 5 and (isinstance(e, frappe.RetryBackgroundJobError) or (frappe.db.is_deadlocked(e) or frappe.db.is_timedout(e))): # retry the job if # 1213 = deadlock # 1205 = lock wait timeout # or RetryBackgroundJobError is explicitly raised frappe.destroy() time.sleep(retry + 1) return execute_job(site, method, event, job_name, kwargs, is_async=is_async, retry=retry + 1) else: frappe.log_error(title=method_name) raise except: frappe.db.rollback() frappe.log_error(title=method_name) frappe.db.commit() print(frappe.get_traceback()) raise else: frappe.db.commit() finally: frappe.monitor.stop() if is_async: frappe.destroy()
def test_create_test_data(): frappe.set_user("Administrator") # create test item if not frappe.db.exists("Item","_Test Tesla Car"): item = frappe.get_doc({ "description": "_Test Tesla Car", "doctype": "Item", "has_batch_no": 0, "has_serial_no": 0, "inspection_required": 0, "is_stock_item": 1, "opening_stock":100, "is_sub_contracted_item": 0, "item_code": "_Test Tesla Car", "item_group": "_Test Item Group", "item_name": "_Test Tesla Car", "apply_warehouse_wise_reorder_level": 0, "warehouse":"Stores - _TC", "gst_hsn_code": "999800", "valuation_rate": 5000, "standard_rate":5000, "item_defaults": [{ "company": "_Test Company", "default_warehouse": "Stores - _TC", "default_price_list":"_Test Price List", "expense_account": "Cost of Goods Sold - _TC", "buying_cost_center": "Main - _TC", "selling_cost_center": "Main - _TC", "income_account": "Sales - _TC" }], "show_in_website": 1, "route":"-test-tesla-car", "website_warehouse": "Stores - _TC" }) item.insert() # create test item price item_price = frappe.get_list('Item Price', filters={'item_code': '_Test Tesla Car', 'price_list': '_Test Price List'}, fields=['name']) if len(item_price)==0: item_price = frappe.get_doc({ "doctype": "Item Price", "item_code": "_Test Tesla Car", "price_list": "_Test Price List", "price_list_rate": 5000 }) item_price.insert() # create test item pricing rule if not frappe.db.exists("Pricing Rule","_Test Pricing Rule for _Test Item"): item_pricing_rule = frappe.get_doc({ "doctype": "Pricing Rule", "title": "_Test Pricing Rule for _Test Item", "apply_on": "Item Code", "items": [{ "item_code": "_Test Tesla Car" }], "warehouse":"Stores - _TC", "coupon_code_based":1, "selling": 1, "rate_or_discount": "Discount Percentage", "discount_percentage": 30, "company": "_Test Company", "currency":"INR", "for_price_list":"_Test Price List" }) item_pricing_rule.insert() # create test item sales partner if not frappe.db.exists("Sales Partner","_Test Coupon Partner"): sales_partner = frappe.get_doc({ "doctype": "Sales Partner", "partner_name":"_Test Coupon Partner", "commission_rate":2, "referral_code": "COPART" }) sales_partner.insert() # create test item coupon code if not frappe.db.exists("Coupon Code", "SAVE30"): coupon_code = frappe.get_doc({ "doctype": "Coupon Code", "coupon_name":"SAVE30", "coupon_code":"SAVE30", "pricing_rule": "_Test Pricing Rule for _Test Item", "valid_from": "2014-01-01", "maximum_use":1, "used":0 }) coupon_code.insert()
def tearDown(self): frappe.set_user("Administrator") set_perpetual_inventory(0) if hasattr(self, "old_default_company"): frappe.db.set_default("company", self.old_default_company)
def tearDown(self): # disable password strength test frappe.db.set_value("System Settings", "System Settings", "enable_password_policy", 0) frappe.db.set_value("System Settings", "System Settings", "minimum_password_score", "") frappe.db.set_value("System Settings", "System Settings", "password_reset_limit", 3) frappe.set_user('Administrator')
def test_set_user_permissions(self): frappe.set_user("*****@*****.**") add("*****@*****.**", "Blog Post", "-test-blog-post")
def __enter__(self): frappe.init(site=self.site) frappe.connect() print frappe.local.site frappe.set_user(self.user)
def test_not_allowed_to_set_user_permissions(self): frappe.set_user("*****@*****.**") # this user can't add user permissions self.assertRaises(frappe.PermissionError, add, "*****@*****.**", "Blog Post", "-test-blog-post")
def work(): frappe.set_user(frappe.db.get_global("demo_hr_user")) year, month = frappe.flags.current_date.strftime("%Y-%m").split("-") setup_department_approvers() mark_attendance() make_leave_application() # payroll entry if not frappe.db.sql( "select name from `tabSalary Slip` where month(adddate(start_date, interval 1 month))=month(curdate())" ): # based on frequency payroll_entry = get_payroll_entry() payroll_entry.salary_slip_based_on_timesheet = 0 payroll_entry.save() payroll_entry.create_salary_slips() payroll_entry.submit_salary_slips() payroll_entry.make_accrual_jv_entry() payroll_entry.submit() # payroll_entry.make_journal_entry(reference_date=frappe.flags.current_date, # reference_number=random_string(10)) # based on timesheet payroll_entry = get_payroll_entry() payroll_entry.salary_slip_based_on_timesheet = 1 payroll_entry.save() payroll_entry.create_salary_slips() payroll_entry.submit_salary_slips() payroll_entry.make_accrual_jv_entry() payroll_entry.submit() # payroll_entry.make_journal_entry(reference_date=frappe.flags.current_date, # reference_number=random_string(10)) if frappe.db.get_global("demo_hr_user"): make_timesheet_records() # expense claim expense_claim = frappe.new_doc("Expense Claim") expense_claim.extend("expenses", get_expenses()) expense_claim.employee = get_random("Employee") expense_claim.company = frappe.flags.company expense_claim.payable_account = get_payable_account( expense_claim.company) expense_claim.posting_date = frappe.flags.current_date expense_claim.expense_approver = frappe.db.get_global("demo_hr_user") expense_claim.save() rand = random.random() if rand < 0.4: update_sanctioned_amount(expense_claim) expense_claim.approval_status = "Approved" expense_claim.submit() if random.randint(0, 1): # make journal entry against expense claim je = frappe.get_doc( make_bank_entry("Expense Claim", expense_claim.name)) je.posting_date = frappe.flags.current_date je.cheque_no = random_string(10) je.cheque_date = frappe.flags.current_date je.flags.ignore_permissions = 1 je.submit()