def test_auth_via_api_key_secret(self): # generate api ke and api secret for administrator keys = generate_keys("Administrator") frappe.db.commit() generated_secret = frappe.utils.password.get_decrypted_password( "User", "Administrator", fieldname='api_secret' ) api_key = frappe.db.get_value("User", "Administrator", "api_key") header = {"Authorization": "token {}:{}".format(api_key, generated_secret)} res = requests.post(frappe.get_site_config().host_name + "/api/method/frappe.auth.get_logged_user", headers=header) self.assertEqual(res.status_code, 200) self.assertEqual("Administrator", res.json()["message"]) self.assertEqual(keys['api_secret'], generated_secret) header = {"Authorization": "Basic {}".format(base64.b64encode(frappe.safe_encode("{}:{}".format(api_key, generated_secret))).decode())} res = requests.post(frappe.get_site_config().host_name + "/api/method/frappe.auth.get_logged_user", headers=header) self.assertEqual(res.status_code, 200) self.assertEqual("Administrator", res.json()["message"]) # Valid api key, invalid api secret api_secret = "ksk&93nxoe3os" header = {"Authorization": "token {}:{}".format(api_key, api_secret)} res = requests.post(frappe.get_site_config().host_name + "/api/method/frappe.auth.get_logged_user", headers=header) self.assertEqual(res.status_code, 403) # random api key and api secret api_key = "@3djdk3kld" api_secret = "ksk&93nxoe3os" header = {"Authorization": "token {}:{}".format(api_key, api_secret)} res = requests.post(frappe.get_site_config().host_name + "/api/method/frappe.auth.get_logged_user", headers=header) self.assertEqual(res.status_code, 401)
def get_field_status(bank_account): enable_otp_based_transaction = frappe.get_site_config( ).bank_api_integration['enable_otp_based_transaction'] acc_num = frappe.get_value("Bank API Integration", {"bank_account": bank_account}, "account_number") is_pwd_security_enabled = frappe.get_value("Bank API Integration", {"bank_account": bank_account}, "enable_password_security") disabled_accounts = frappe.get_site_config( ).bank_api_integration['disable_transaction'] data = {} if disabled_accounts == '*' or acc_num in disabled_accounts: frappe.throw( _(f'Unable to process transaction for the selected bank account. Please contact Administrator.' )) return if (enable_otp_based_transaction == '*' or acc_num in enable_otp_based_transaction): data['is_otp_enabled'] = 1 if (is_pwd_security_enabled): data['is_pwd_security_enabled'] = 1 return data
def make_log(**kwargs): tags = kwargs.get("tags") or [] if isinstance(tags, string_types): if tags.startswith("["): tags = frappe.parse_json(tags) else: tags = [tags] tags.append(frappe.local.site) kwargs["tags"] = frappe.as_json(tags) header = requests.utils.default_headers() header.update({ "Accept": "application/json", 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36' }) if not frappe.get_site_config().get("log_url"): # frappe.local.request will exist when invoked over API # background workers wont have 'request' if hasattr(frappe.local, "request"): frappe.throw("No Log URL is mentioned in the site_config") return "no-log-url" r = requests.post(frappe.get_site_config().get("log_url"), json=frappe._dict(cmd="renovation_logging.api.make_log", user=frappe.session.user, **kwargs), headers=header) if not r.ok: frappe.throw(r.text) return r.json().get("message")
def test_site_expiry(self): user = frappe.get_doc('User', '*****@*****.**') user.enabled = 1 user.new_password = '******' user.save() update_limits({ 'expiry': add_to_date(today(), days=-1), 'support_email': '*****@*****.**' }) frappe.local.conf = _dict(frappe.get_site_config()) frappe.db.commit() res = requests.post(get_url(), params={ 'cmd': 'login', 'usr': '******', 'pwd': 'Eastern_43A1W', 'device': 'desktop' }) # While site is expired status code returned is 417 Failed Expectation self.assertEqual(res.status_code, 417) clear_limit("expiry") frappe.local.conf = _dict(frappe.get_site_config())
def test_insert_note(self): # Go to Authorize url self.driver.get( "api/method/frappe.integrations.oauth2.authorize?client_id=" + self.client_id + "&scope=all%20openid&response_type=code&redirect_uri=http%3A%2F%2Flocalhost" ) time.sleep(2) # Login username = self.driver.find("#login_email")[0] username.send_keys("*****@*****.**") password = self.driver.find("#login_password")[0] password.send_keys("Eastern_43A1W") sign_in = self.driver.find(".btn-login")[0] sign_in.submit() time.sleep(2) # Allow access to resource allow = self.driver.find("#allow")[0] allow.click() time.sleep(2) # Get authorization code from redirected URL auth_code = urlparse(self.driver.driver.current_url).query.split("=")[1] payload = "grant_type=authorization_code&code=" payload += auth_code payload += "&redirect_uri=http%3A%2F%2Flocalhost&client_id=" payload += self.client_id headers = {'content-type':'application/x-www-form-urlencoded'} # Request for bearer token token_response = requests.post( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.get_token", data=payload, headers=headers) # Parse bearer token json bearer_token = token_response.json() client = FrappeOAuth2Client(frappe.get_site_config().host_name, bearer_token.get("access_token")) notes = [ {"doctype": "Note", "title": "Sing", "public": True}, {"doctype": "Note", "title": "a", "public": True}, {"doctype": "Note", "title": "Song", "public": True}, {"doctype": "Note", "title": "of", "public": True}, {"doctype": "Note", "title": "sixpence", "public": True} ] for note in notes: client.insert(note) self.assertTrue(len(frappe.get_all("Note")) == 5)
def test_allow_login_using_username_and_mobile(self): self.set_system_settings("allow_login_using_mobile_number", 1) self.set_system_settings("allow_login_using_user_name", 1) # Both email and username and mobile logins should work FrappeClient(frappe.get_site_config().host_name, self.test_user_mobile, self.test_user_password) FrappeClient(frappe.get_site_config().host_name, self.test_user_email, self.test_user_password) FrappeClient(frappe.get_site_config().host_name, self.test_user_name, self.test_user_password)
def test_login_using_authorization_code(self): client = frappe.get_doc("OAuth Client", self.client_id) client.grant_type = "Authorization Code" client.response_type = "Code" client.save() frappe.db.commit() session = requests.Session() # Login session.post(frappe.get_site_config().host_name + "/api/method/login", data={ "usr": "******", "pwd": "Eastern_43A1W" }) redirect_destination = None # Go to Authorize url try: session.get( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.authorize?client_id=" + self.client_id + "&scope=all%20openid&response_type=code&redirect_uri=http%3A%2F%2Flocalhost" ) except requests.exceptions.ConnectionError as ex: redirect_destination = ex.request.url # Get authorization code from redirected URL auth_code = urlparse(redirect_destination).query.split("=")[1] payload = "grant_type=authorization_code&code=" payload += auth_code payload += "&redirect_uri=http%3A%2F%2Flocalhost&client_id=" payload += self.client_id headers = {'content-type': 'application/x-www-form-urlencoded'} # Request for bearer token token_response = requests.post( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.get_token", data=payload, headers=headers) # Parse bearer token json bearer_token = token_response.json() self.assertTrue(bearer_token.get("access_token")) self.assertTrue(bearer_token.get("expires_in")) self.assertTrue(bearer_token.get("id_token")) self.assertTrue(bearer_token.get("refresh_token")) self.assertTrue(bearer_token.get("scope")) self.assertTrue(bearer_token.get("token_type") == "Bearer") self.assertTrue( check_valid_openid_response(bearer_token.get("access_token")))
def test_allow_login_using_username(self): self.set_system_settings("allow_login_using_mobile_number", 0) self.set_system_settings("allow_login_using_user_name", 1) # Mobile login should fail with self.assertRaises(AuthError): FrappeClient(frappe.get_site_config().host_name, self.test_user_mobile, self.test_user_password) # Both email and username logins should work FrappeClient(frappe.get_site_config().host_name, self.test_user_email, self.test_user_password) FrappeClient(frappe.get_site_config().host_name, self.test_user_name, self.test_user_password)
def test_restrict_scheduler_events(self): frappe.set_user("Administrator") dormant_date = add_days(today(), -5) frappe.db.sql('update tabUser set last_active=%s', dormant_date) restrict_scheduler_events_if_dormant() frappe.local.conf = _dict(frappe.get_site_config()) self.assertFalse("all" in get_enabled_scheduler_events()) self.assertTrue(frappe.conf.get('dormant', False)) clear_limit("expiry") frappe.local.conf = _dict(frappe.get_site_config())
def test_allow_login_using_only_email(self): self.set_system_settings("allow_login_using_mobile_number", 0) self.set_system_settings("allow_login_using_user_name", 0) # Login by mobile number should fail with self.assertRaises(AuthError): FrappeClient(frappe.get_site_config().host_name, self.test_user_mobile, self.test_user_password) # login by username should fail with self.assertRaises(AuthError): FrappeClient(frappe.get_site_config().host_name, self.test_user_name, self.test_user_password) # Login by email should work FrappeClient(frappe.get_site_config().host_name, self.test_user_email, self.test_user_password)
def test_allow_login_using_mobile(self): self.set_system_settings('allow_login_using_mobile_number', 1) self.set_system_settings('allow_login_using_user_name', 0) # Login by both email and mobile should work FrappeClient(frappe.get_site_config().host_name, self.test_user_mobile, self.test_user_password) FrappeClient(frappe.get_site_config().host_name, self.test_user_email, self.test_user_password) # login by username should fail with self.assertRaises(AuthError): FrappeClient(frappe.get_site_config().host_name, self.test_user_name, self.test_user_password)
def test_site_expiry(self): update_limits({'expiry': add_to_date(today(), days=-1)}) frappe.local.conf = _dict(frappe.get_site_config()) frappe.db.commit() res = requests.post(get_url(), params={'cmd': 'login', 'usr': '******', 'pwd': 'testpassword', 'device': 'desktop'}) # While site is expired status code returned is 417 Failed Expectation self.assertEqual(res.status_code, 417) clear_limit("expiry") frappe.local.conf = _dict(frappe.get_site_config())
def test_site_expiry(self): update_limits({"expiry": add_to_date(today(), days=-1)}) frappe.local.conf = _dict(frappe.get_site_config()) frappe.db.commit() res = requests.post( get_url(), params={"cmd": "login", "usr": "******", "pwd": "testpassword", "device": "desktop"} ) # While site is expired status code returned is 417 Failed Expectation self.assertEqual(res.status_code, 417) clear_limit("expiry") frappe.local.conf = _dict(frappe.get_site_config())
def test_restrict_scheduler_events(self): frappe.set_user("Administrator") user = frappe.get_doc("User", "Administrator") dormant_date = add_days(today(), -5) user.last_active = dormant_date user.save() restrict_scheduler_events_if_dormant() frappe.local.conf = _dict(frappe.get_site_config()) self.assertFalse("all" in get_enabled_scheduler_events()) self.assertTrue(frappe.conf.get('dormant', False)) clear_limit("expiry") frappe.local.conf = _dict(frappe.get_site_config())
def get_api_provider_class(company_bank_account): integration_doc = frappe.get_doc('Bank API Integration', {'bank_account': company_bank_account}) proxies = frappe.get_site_config().bank_api_integration['proxies'] config = { "APIKEY": integration_doc.get_password( fieldname="api_key") if integration_doc.api_key else None, "CORPID": integration_doc.corp_id, "USERID": integration_doc.user_id, "AGGRID": integration_doc.aggr_id, "AGGRNAME": integration_doc.aggr_name, "URN": integration_doc.urn } file_paths = { 'private_key': integration_doc.get_password(fieldname="private_key_path") if integration_doc.private_key_path else None, 'public_key': frappe.local.site_path + integration_doc.public_key_attachment if integration_doc.public_key_attachment else None } prov = CommonProvider(integration_doc.bank_api_provider, config, integration_doc.use_sandbox, proxies, file_paths, frappe.local.site_path) return prov, config
def notify_telegram(doc, method): config = frappe.get_site_config() if config["developer_mode"] != 1: send_telegram( doc.title, frappe.db.get_value("Telegram Settings", None, "chat_id"), frappe.db.get_value("Telegram Settings", None, "api_key"))
def emulate_request(): # Emulate Woocommerce Request headers = { "X-Wc-Webhook-Event": "created", "X-Wc-Webhook-Signature": "h1SjzQMPwd68MF5bficeFq20/RkQeRLsb9AVCUz/rLs=" } # Emulate Request Data data = """{"id":74,"parent_id":0,"number":"74","order_key":"wc_order_5aa1281c2dacb","created_via":"checkout","version":"3.3.3","status":"processing","currency":"INR","date_created":"2018-03-08T12:10:04","date_created_gmt":"2018-03-08T12:10:04","date_modified":"2018-03-08T12:10:04","date_modified_gmt":"2018-03-08T12:10:04","discount_total":"0.00","discount_tax":"0.00","shipping_total":"150.00","shipping_tax":"0.00","cart_tax":"0.00","total":"649.00","total_tax":"0.00","prices_include_tax":false,"customer_id":12,"customer_ip_address":"103.54.99.5","customer_user_agent":"mozilla\\/5.0 (x11; linux x86_64) applewebkit\\/537.36 (khtml, like gecko) chrome\\/64.0.3282.186 safari\\/537.36","customer_note":"","billing":{"first_name":"Tony","last_name":"Stark","company":"Woocommerce","address_1":"Mumbai","address_2":"","city":"Dadar","state":"MH","postcode":"123","country":"IN","email":"*****@*****.**","phone":"123457890"},"shipping":{"first_name":"Tony","last_name":"Stark","company":"","address_1":"Mumbai","address_2":"","city":"Dadar","state":"MH","postcode":"123","country":"IN"},"payment_method":"cod","payment_method_title":"Cash on delivery","transaction_id":"","date_paid":null,"date_paid_gmt":null,"date_completed":null,"date_completed_gmt":null,"cart_hash":"8e76b020d5790066496f244860c4703f","meta_data":[],"line_items":[{"id":80,"name":"Marvel","product_id":56,"variation_id":0,"quantity":1,"tax_class":"","subtotal":"499.00","subtotal_tax":"0.00","total":"499.00","total_tax":"0.00","taxes":[],"meta_data":[],"sku":"","price":499}],"tax_lines":[],"shipping_lines":[{"id":81,"method_title":"Flat rate","method_id":"flat_rate:1","total":"150.00","total_tax":"0.00","taxes":[],"meta_data":[{"id":623,"key":"Items","value":"Marvel × 1"}]}],"fee_lines":[],"coupon_lines":[],"refunds":[]}""" # Build URL port = frappe.get_site_config().webserver_port or '8000' if os.environ.get('CI'): host = 'localhost' else: host = frappe.local.site url = "http://{site}:{port}/api/method/erpnext.erpnext_integrations.connectors.woocommerce_connection.order".format( site=host, port=port) r = requests.post(url=url, headers=headers, data=data) time.sleep(5) return r
def test_resource_owner_password_credentials_grant(self): client = frappe.get_doc("OAuth Client", self.client_id) client.grant_type = "Authorization Code" client.response_type = "Code" client.save() frappe.db.commit() # Set payload payload = "grant_type=password" payload += "&[email protected]" payload += "&password=Eastern_43A1W" payload += "&client_id=" + self.client_id payload += "&scope=openid%20all" headers = {'content-type': 'application/x-www-form-urlencoded'} # Request for bearer token token_response = requests.post( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.get_token", data=payload, headers=headers) # Parse bearer token json bearer_token = token_response.json() # Check token for valid response self.assertTrue( check_valid_openid_response(bearer_token.get("access_token")))
def show_config(context): "print configuration file" print("\t\033[92m{:<50}\033[0m \033[92m{:<15}\033[0m".format('Config','Value')) sites_path = os.path.join(frappe.utils.get_bench_path(), 'sites') site_path = context.sites[0] configuration = frappe.get_site_config(sites_path=sites_path, site_path=site_path) print_config(configuration)
def make_log(**kwargs): tags = kwargs.get("tags") or [] if isinstance(tags, string_types): if tags.startswith("["): tags = frappe.parse_json(tags) else: tags = [tags] tags.append(frappe.local.site) kwargs["tags"] = frappe.as_json(tags) header = requests.utils.default_headers() header.update({ "Accept": "application/json", 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36' }) r = requests.post( frappe.get_site_config().get("log_url"), json=frappe._dict( cmd="renovation_logging.api.make_log", user=frappe.session.user, **kwargs ), headers=header ) if not r.ok: frappe.throw(r.text) return r.json().get("message")
def setup_global_help(db_type=None, root_password=None): '''setup help table in a separate database that will be shared by the whole bench and set `global_help_setup` as 1 in common_site_config.json''' from frappe.installer import update_site_config frappe.local.flags = frappe._dict() frappe.local.flags.in_setup_help = True frappe.local.flags.in_install = True frappe.local.lang = 'en' frappe.local.conf = frappe.get_site_config(sites_path='.') update_site_config('global_help_setup', 1, site_config_path=os.path.join('.', 'common_site_config.json')) if root_password: frappe.local.conf.root_password = root_password if not frappe.local.conf.db_type: frappe.local.conf.db_type = db_type from frappe.utils.help import sync sync()
def test_list_docs(self): server = FrappeClient(frappe.get_site_config().host_name, "Administrator", "admin", verify=False) doc_list = server.get_list("Note") self.assertTrue(len(doc_list))
def test_login_to_authorize_url(self): # Go to Authorize url self.driver.get( "api/method/frappe.integrations.oauth2.authorize?client_id=" + self.client_id + "&scope=all%20openid&response_type=code&redirect_uri=http%3A%2F%2Flocalhost" ) time.sleep(2) # Login username = self.driver.find("#login_email")[0] username.send_keys("*****@*****.**") password = self.driver.find("#login_password")[0] password.send_keys("Eastern_43A1W") sign_in = self.driver.find(".btn-login")[0] sign_in.submit() time.sleep(2) # Allow access to resource allow = self.driver.find("#allow")[0] allow.click() time.sleep(2) # Get authorization code from redirected URL auth_code = urlparse( self.driver.driver.current_url).query.split("=")[1] payload = "grant_type=authorization_code&code=" payload += auth_code payload += "&redirect_uri=http%3A%2F%2Flocalhost&client_id=" payload += self.client_id headers = {'content-type': 'application/x-www-form-urlencoded'} # Request for bearer token token_response = requests.post( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.get_token", data=payload, headers=headers) # Parse bearer token json bearer_token = token_response.json() self.assertTrue(bearer_token.get("access_token")) self.assertTrue(bearer_token.get("expires_in")) self.assertTrue(bearer_token.get("id_token")) self.assertTrue(bearer_token.get("refresh_token")) self.assertTrue(bearer_token.get("scope")) self.assertTrue(bearer_token.get("token_type") == "Bearer")
def test_site_expiry(self): user = frappe.get_doc('User', '*****@*****.**') user.enabled = 1 user.new_password = '******' user.save() update_limits({'expiry': add_to_date(today(), days=-1), 'support_email': '*****@*****.**'}) frappe.local.conf = _dict(frappe.get_site_config()) frappe.db.commit() res = requests.post(get_url(), params={'cmd': 'login', 'usr': '******', 'pwd': 'Eastern_43A1W', 'device': 'desktop'}) # While site is expired status code returned is 417 Failed Expectation self.assertEqual(res.status_code, 417) clear_limit("expiry") frappe.local.conf = _dict(frappe.get_site_config())
def get_firebase_certificate(): import os cred = frappe.get_site_config().get("firebase_service_account", None) if not cred and os.path.isfile("firebase-adminsdk-cred.json"): cred = "firebase-adminsdk-cred.json" if not cred: frappe.throw("Please define firebase_service_account in site_config") return credentials.Certificate(cred)
def get_mediator_creds(): d = frappe.get_site_config().get("mediator_creds") if not d: frappe.throw( "Please specify mediator_creds in site config of Agents Bench Manager site") for x in ["mediator_url", "api_key", "api_secret"]: if x not in d: frappe.throw("Please specify {} in mediator_creds".format(x)) return frappe._dict(d)
def notify_slack(doc, method): config = frappe.get_site_config() if config["developer_mode"] != 1: if frappe.db.get_value("Slack Settings", None, "icon"): icon = frappe.db.get_value("Slack Settings", None, "icon") else: icon = ':ghost:' send_slack(doc.error, frappe.db.get_value("Slack Settings", None, "bot_name"), frappe.db.get_value("Slack Settings", None, "channel"), icon)
def get_celery(): global _app if not _app: conf = frappe.get_site_config(sites_path=SITES_PATH) _app = Celery('frappe', broker=conf.celery_broker or DEFAULT_CELERY_BROKER, backend=conf.celery_result_backend or DEFAULT_CELERY_BACKEND) setup_celery(_app, conf) return _app
def get_celery(): global _app if not _app: conf = frappe.get_site_config(sites_path=SITES_PATH) _app = Celery('frappe', broker=conf.celery_broker or DEFAULT_CELERY_BROKER, backend=conf.async_redis_server or DEFAULT_CELERY_BACKEND) setup_celery(_app, conf) return _app
def test_disable_scheduler_on_expiry(self): update_limits({'expiry': add_to_date(today(), days=-1)}) frappe.local.conf = _dict(frappe.get_site_config()) if not frappe.db.exists('User', '*****@*****.**'): user = frappe.new_doc('User') user.email = '*****@*****.**' user.first_name = 'Test_scheduler' user.save() user.add_roles('System Manager') frappe.db.commit() frappe.set_user("*****@*****.**") disable_scheduler_on_expiry() ss = frappe.get_doc("System Settings") self.assertFalse(ss.enable_scheduler) clear_limit("expiry") frappe.local.conf = _dict(frappe.get_site_config())
def test_login_using_authorization_code(self): # Go to Authorize url self.driver.get( "api/method/frappe.integrations.oauth2.authorize?client_id=" + self.client_id + "&scope=all%20openid&response_type=code&redirect_uri=http%3A%2F%2Flocalhost" ) time.sleep(2) # Login username = self.driver.find("#login_email")[0] username.send_keys("*****@*****.**") password = self.driver.find("#login_password")[0] password.send_keys("Eastern_43A1W") sign_in = self.driver.find(".btn-login")[0] sign_in.submit() time.sleep(2) # Allow access to resource allow = self.driver.find("#allow")[0] allow.click() time.sleep(2) # Get authorization code from redirected URL auth_code = urlparse(self.driver.driver.current_url).query.split("=")[1] payload = "grant_type=authorization_code&code=" payload += auth_code payload += "&redirect_uri=http%3A%2F%2Flocalhost&client_id=" payload += self.client_id headers = {'content-type':'application/x-www-form-urlencoded'} # Request for bearer token token_response = requests.post( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.get_token", data=payload, headers=headers) # Parse bearer token json bearer_token = token_response.json() self.assertTrue(bearer_token.get("access_token")) self.assertTrue(bearer_token.get("expires_in")) self.assertTrue(bearer_token.get("id_token")) self.assertTrue(bearer_token.get("refresh_token")) self.assertTrue(bearer_token.get("scope")) self.assertTrue(bearer_token.get("token_type") == "Bearer")
def check_valid_openid_response(access_token=None): # Returns True for valid response # Use token in header headers = {} if access_token: headers["Authorization"] = 'Bearer' + access_token # check openid for email [email protected] openid_response = requests.get(frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.openid_profile", headers=headers) return True if openid_response.status_code == 200 else False
def test_login_using_implicit_token(self): oauth_client = frappe.get_doc("OAuth Client", self.client_id) oauth_client.grant_type = "Implicit" oauth_client.response_type = "Token" oauth_client.save() frappe.db.commit() session = requests.Session() # Login session.post(frappe.get_site_config().host_name + "/api/method/login", data={ "usr": "******", "pwd": "Eastern_43A1W" }) redirect_destination = None # Go to Authorize url try: session.get( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.authorize?client_id=" + self.client_id + "&scope=all%20openid&response_type=token&redirect_uri=http%3A%2F%2Flocalhost" ) except requests.exceptions.ConnectionError as ex: redirect_destination = ex.request.url response_url = dict(parse_qs(urlparse(redirect_destination).fragment)) self.assertTrue(response_url.get("access_token")) self.assertTrue(response_url.get("expires_in")) self.assertTrue(response_url.get("scope")) self.assertTrue(response_url.get("token_type")) self.assertTrue( check_valid_openid_response(response_url.get("access_token")[0]))
def update_site_config(site_config, verbose=False): import json if isinstance(site_config, basestring): site_config = json.loads(site_config) config = frappe.get_site_config() config.update(site_config) site_config_path = os.path.join(frappe.local.site_path, "site_config.json") with open(site_config_path, "w") as f: json.dump(config, f, indent=1, sort_keys=True) frappe.destroy()
def test_update_doc(self): server = FrappeClient(frappe.get_site_config().host_name, "Administrator", "admin", verify=False) frappe.db.sql('delete from `tabNote` where title = "sing"') frappe.db.commit() server.insert({"doctype": "Note", "public": True, "title": "Sing"}) doc = server.get_doc("Note", 'Sing') changed_title = "sing" doc["title"] = changed_title doc = server.update(doc) self.assertTrue(doc["title"] == changed_title)
def get_celery(): global _app if not _app: conf = frappe.get_site_config(sites_path=SITES_PATH) _app = Celery( "frappe", broker=conf.celery_broker or DEFAULT_CELERY_BROKER, backend=conf.celery_result_backend or DEFAULT_CELERY_BACKEND, ) setup_celery(_app, conf) return _app
def test_file_upload_limit(self): from frappe.utils.file_manager import MaxFileSizeReachedError from frappe.limits import update_limits, clear_limit from frappe import _dict update_limits({ 'space': 1, 'space_usage': { 'files_size': (1024 ** 2), 'database_size': 0, 'backup_size': 0, 'total': (1024 ** 2) } }) # Rebuild the frappe.local.conf to take up the changes from site_config frappe.local.conf = _dict(frappe.get_site_config()) self.assertRaises(MaxFileSizeReachedError, save_file, '_test_max_space.txt', 'This files test for max space usage', "", "", self.get_folder("Test Folder 2", "Home").name) # Scrub the site_config and rebuild frappe.local.conf clear_limit("space") frappe.local.conf = _dict(frappe.get_site_config())
def setup_logging(): conf = frappe.get_site_config(sites_path=os.environ.get('SITES_PATH', '.')) if conf.logging_conf: logging_conf = conf.logging_conf else: logging_conf = { "version": 1, "disable_existing_loggers": True, "filters": { "context_filter": { "()": "frappe.setup_logging.ContextFilter" } }, "formatters": { "site_wise": { "format": "\n%(asctime)s %(message)s \n site: %(site)s\n form: %(form_dict)s\n\n%(tb)s\n--------------" } }, "loggers": { "frappe": { "level": "INFO", "propagate": False, "filters": ["context_filter"], "handlers": ["request_exception"] } }, "handlers": { "request_exception": { "level": "INFO", "formatter": "site_wise", "class": "logging.StreamHandler", } } } if conf.request_exception_log_file: logging_conf.update({ "handlers": { "request_exception": { "level": "INFO", "formatter": "site_wise", "class": "logging.handlers.WatchedFileHandler", "filename": conf.request_exception_log_file } } }) logging.config.dictConfig(logging_conf)
def test_resource_owner_password_credentials_grant(self): # Set payload payload = "grant_type=password" payload += "&[email protected]" payload += "&password=Eastern_43A1W" payload += "&client_id=" + self.client_id payload += "&scope=openid%20all" headers = {'content-type':'application/x-www-form-urlencoded'} # Request for bearer token token_response = requests.post( frappe.get_site_config().host_name + "/api/method/frappe.integrations.oauth2.get_token", data=payload, headers=headers) # Parse bearer token json bearer_token = token_response.json() # Check token for valid response self.assertTrue(check_valid_openid_response(bearer_token.get("access_token")))
def test_user_limit_for_site(self): update_limits({'users': get_total_users()}) # reload site config from frappe import _dict frappe.local.conf = _dict(frappe.get_site_config()) # Create a new user user = frappe.new_doc('User') user.email = '*****@*****.**' user.first_name = 'Test_max_user' self.assertRaises(MaxUsersReachedError, user.add_roles, 'System Manager') if frappe.db.exists('User', '*****@*****.**'): frappe.delete_doc('User', '*****@*****.**') # Clear the user limit clear_limit('users')
def setup_global_help(mariadb_root_password=None): '''setup help table in a separate database that will be shared by the whole bench and set `global_help_setup` as 1 in common_site_config.json''' from frappe.installer import update_site_config frappe.local.flags = frappe._dict() frappe.local.flags.in_setup_help = True frappe.local.flags.in_install = True frappe.local.lang = 'en' frappe.local.conf = frappe.get_site_config(sites_path='.') update_site_config('global_help_setup', 1, site_config_path=os.path.join('.', 'common_site_config.json')) if mariadb_root_password: frappe.local.conf.root_password = mariadb_root_password from frappe.utils.help import sync sync()
def test_user_limit_for_site(self): from frappe.core.doctype.user.user import get_total_users update_limits({"users": get_total_users()}) # reload site config from frappe import _dict frappe.local.conf = _dict(frappe.get_site_config()) # Create a new user user = frappe.new_doc("User") user.email = "*****@*****.**" user.first_name = "Test_max_user" self.assertRaises(MaxUsersReachedError, user.add_roles, "System Manager") if frappe.db.exists("User", "*****@*****.**"): frappe.delete_doc("User", "*****@*****.**") # Clear the user limit clear_limit("users")
def __init__(self, port=None): self.port = port or frappe.get_site_config().webserver_port or '8000' chrome_options = Options() capabilities = DesiredCapabilities.CHROME if os.environ.get('CI'): self.host = 'localhost' else: self.host = frappe.local.site # enable browser logging capabilities['loggingPrefs'] = {'browser':'ALL'} chrome_options.add_argument('--no-sandbox') chrome_options.add_argument('--start-maximized') self.driver = webdriver.Chrome(chrome_options=chrome_options, desired_capabilities=capabilities, port=9515) self.driver.set_window_size(1080,800) self.cur_route = None self.logged_in = False
def emulate_request(): # Emulate Woocommerce Request headers = { "X-Wc-Webhook-Event":"created", "X-Wc-Webhook-Signature":"h1SjzQMPwd68MF5bficeFq20/RkQeRLsb9AVCUz/rLs=" } # Emulate Request Data data = """{"id":74,"parent_id":0,"number":"74","order_key":"wc_order_5aa1281c2dacb","created_via":"checkout","version":"3.3.3","status":"processing","currency":"INR","date_created":"2018-03-08T12:10:04","date_created_gmt":"2018-03-08T12:10:04","date_modified":"2018-03-08T12:10:04","date_modified_gmt":"2018-03-08T12:10:04","discount_total":"0.00","discount_tax":"0.00","shipping_total":"150.00","shipping_tax":"0.00","cart_tax":"0.00","total":"649.00","total_tax":"0.00","prices_include_tax":false,"customer_id":12,"customer_ip_address":"103.54.99.5","customer_user_agent":"mozilla\\/5.0 (x11; linux x86_64) applewebkit\\/537.36 (khtml, like gecko) chrome\\/64.0.3282.186 safari\\/537.36","customer_note":"","billing":{"first_name":"Tony","last_name":"Stark","company":"Woocommerce","address_1":"Mumbai","address_2":"","city":"Dadar","state":"MH","postcode":"123","country":"IN","email":"*****@*****.**","phone":"123457890"},"shipping":{"first_name":"Tony","last_name":"Stark","company":"","address_1":"Mumbai","address_2":"","city":"Dadar","state":"MH","postcode":"123","country":"IN"},"payment_method":"cod","payment_method_title":"Cash on delivery","transaction_id":"","date_paid":null,"date_paid_gmt":null,"date_completed":null,"date_completed_gmt":null,"cart_hash":"8e76b020d5790066496f244860c4703f","meta_data":[],"line_items":[{"id":80,"name":"Marvel","product_id":56,"variation_id":0,"quantity":1,"tax_class":"","subtotal":"499.00","subtotal_tax":"0.00","total":"499.00","total_tax":"0.00","taxes":[],"meta_data":[],"sku":"","price":499}],"tax_lines":[],"shipping_lines":[{"id":81,"method_title":"Flat rate","method_id":"flat_rate:1","total":"150.00","total_tax":"0.00","taxes":[],"meta_data":[{"id":623,"key":"Items","value":"Marvel × 1"}]}],"fee_lines":[],"coupon_lines":[],"refunds":[]}""" # Build URL port = frappe.get_site_config().webserver_port or '8000' if os.environ.get('CI'): host = 'localhost' else: host = frappe.local.site url = "http://{site}:{port}/api/method/erpnext.erpnext_integrations.connectors.woocommerce_connection.order".format(site=host, port=port) r = requests.post(url=url, headers=headers, data=data) time.sleep(5) return r
def get_site_config(): return frappe.get_site_config(sites_path=SITES_PATH)