def topup(): form = CreditForm() if request.method == 'POST': msg = "" token = request.form['id'] # Using Flask amount = request.form['amount'] charge = stripe.Charge.create( amount=amount, currency='nzd', description='vr 360 service fee', source=token, ) # todo how to know charge is success? try: if 'id_token' in session and 'access_token' in session and 'refresh_token': u = Cognito(cognito_userpool_id, cognito_client_id, cognito_userpool_region, id_token=session['id_token'], refresh_token=session['refresh_token'], access_token=session['access_token'], username=current_user.id) topup_amount = int(float(amount) / 100) user = u.get_user() balance = int(user._data['custom:credit']) new_balance = topup_amount + balance u.update_profile({'custom:credit': str(new_balance)}) user = u.get_user() balance = user._data['custom:credit'] session['credit'] = balance current_user.credit = balance else: raise Exception("Charged,but fail to topup the account") except Exception as e: if hasattr(e, 'message'): msg = e.message else: msg = e else: msg = "Topup Successfully" finally: # flash(msg) return msg #render_template("topup.html",form=form, key=stripe_keys['publishable_key'])#redirect(url_for("topup")) elif request.method == 'GET': return render_template("topup.html", form=form, key=stripe_keys['publishable_key'])
def load_user_from_request_header(request): try: access_token_enc = request.headers["Authorization"] access_token_dec = auth.decodeJWT(access_token_enc) if(access_token_dec['exp'] < time.time()): return None # id_token_enc = request.headers["ID"] # kid = jwt.get_unverified_header(id_token_enc)['kid'] # key = public_keys[kid] # access_token_dec = jwt.decode(id_token_enc, public_keys[kid], algorithms='RS256') access_token = request.headers["Authorization"] cognito = Cognito( environ.get('COGNITO_REGION'), environ.get('COGNITO_ACCESS'), access_token=access_token, user_pool_region='us-east-2') username = cognito.get_user()._metadata.get("username") if username is None: return None return User(username) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] print(exc_type, fname, exc_tb.tb_lineno) print(e) return None
def authenticate_user(config, username, password): u = Cognito(config['aws']['cognitio']['userPoolId'], config['aws']['cognitio']['userPoolClientId'], username=username) u.authenticate(password=password) user = u.get_user(attr_map={ "given_name": "first_name", "family_name": "last_name" }) print user.username, user.email_verified, u.access_token return u.access_token
def load_user_from_request_header(request): try: access_token = request.headers.get("X-LiQR-Authorization") id_token = request.headers.get("X-LiQR-ID") unique_id = request.form['unique_id'] name = request.form['name'] # sys.stderr.write("LiQR_Error: " + access_token+ " who is a " + str(request.args) + " connected\n") cognito = Cognito("ap-south-1_v9uz3gNH6", "2oauo7q0odvn3c99dsevmstk54", user_pool_region="ap-south-1", access_token=access_token, id_token=id_token) username = cognito.get_user().sub phone_number = cognito.get_user().phone_number # sys.stderr.write("LiQR_Error: " + phone_number + " who is a " + " connected\n") # sys.stderr.write("LiQR_Error: " + username + " who is a " + " connected\n") # sys.stderr.write("LiQR_Error: " + unique_id + " who is a " + " connected\n") if len(AppUser.objects(username=username)) == 0: print("New user here") the_user = PhoneUser(phone_no=phone_number, unique_id=unique_id, name=name, aws_id=username).save() app_user = AppUser(username=username, user_type="neo_customer", rest_user=the_user.to_dbref(), timestamp=datetime.now()).save() return app_user if username is None: return None print("Old user") return AppUser.objects(username=username).first() except Exception as e: print(e) return None
def test_valid_login(): client_id = "5bl2caob065vqodmm3sobp3k7d" user_pool_id = "eu-west-1_mQ0D78123" login(username, password) user_details = User.get_instance() u = Cognito(client_id=client_id, user_pool_id=user_pool_id, username=username, user_pool_region='eu-west-1') u.authenticate(password=password) user = u.get_user(attr_map={"user_id": "sub"}) assert user_details.user_id == user.sub assert user_details.username == user.username assert user_details.hcp_id != 0
def sign_in(): if request and request.method == "GET": resp, err = GetUserPasswordFromAuthHeader(request) if err: log.error(err) res = GetResponseObject(err, 400) return res username, password = resp[0], resp[1] try: user = Cognito(user_pool_id=COGNITO_USER_POOL_ID, \ client_id=COGNITO_APP_CLIENT_ID, \ user_pool_region=AWS_REGION, \ username=username) user.admin_authenticate(password=password) user_rec = user.get_user() uid = user_rec.sub usertype = user_rec._data['custom:usertype'] userObj = Users.get(uid) # userObj = Users.get(uid, usertype) out = SerializeUserObj(userObj) # out["usertype"] = usertype data = { # "idToken": user.id_token, "accessToken": user.access_token, # "refreshToken": user.refresh_token, "profile": out } res = GetResponseObject(data, 200, True) res.headers['HMS-TOKEN'] = "Bearer " + user.access_token # res.set_cookie(settings.COOKIE_NAME , user.access_token) return res except Exception as e: msg = f"Error while authenticating user {str(e)}" return GetResponseObject(msg) # return HttpResponseServerError(res) else: data = f"Invalid request method, method {request.method} not supported !!!" return GetResponseObject(data, 405)
def cog_test_authenticate(self): cognito = Cognito( 'us-east-1_V2t2miGey', '3nlvl0p7duau88cbbmd3pv337o', user_pool_region='us-east-1', client_secret='4q67ap5cb1msfci67v5p7bgv3buam78mvvhcbbmgq9va9konod4', username='******') # cognito = Cognito('us-east-1_iWsiqRN3n', '4stcts76mik8nvc1rjef5s3c3p', # user_pool_region='us-east-1', # client_secret='5n2kp1j7p818hril9eqcmgsqqjqedfgou544rrf9qjk29dkispm', # username='******') # cognito = Cognito('us-east-1_V2t2miGey', '3nlvl0p7duau88cbbmd3pv337o', # user_pool_region='us-east-1', # client_secret='4q67ap5cb1msfci67v5p7bgv3buam78mvvhcbbmgq9va9konod4') # Registration # cognito.add_base_attributes(email='*****@*****.**') # # cognito.register('nauge1', 'Nauge009#') # # cognito.admin_confirm_sign_up(username='******') # Authentication cognito.authenticate(password='******') access_token = cognito.access_token id_token = cognito.id_token refresh_token = cognito.refresh_token user = cognito.get_user(attr_map={"email": "email"}) user_emnail = user._data['email'] # Delete User # cognito.authenticate(password='******') # cognito.delete_user() self.logger.debug("Cognito:")
class PyEmVue(object): def __init__(self): self.username = None self.token_storage_file = None self.customer = None self.cognito = None def get_devices(self): """Get all devices under the current customer account.""" url = API_ROOT + API_CUSTOMER_DEVICES.format(customerGid = self.customer.customer_gid) response = self._get_request(url) response.raise_for_status() devices = [] if response.text: j = response.json() if 'devices' in j: for dev in j['devices']: devices.append(VueDevice().from_json_dictionary(dev)) if 'devices' in dev: for subdev in dev['devices']: devices.append(VueDevice().from_json_dictionary(subdev)) return devices def populate_device_properties(self, device): """Get details about a specific device""" url = API_ROOT + API_DEVICE_PROPERTIES.format(deviceGid=device.device_gid) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() device.populate_location_properties_from_json(j) return device def get_customer_details(self): """Get details for the current customer.""" url = API_ROOT + API_CUSTOMER.format(email=quote(self.username)) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() return Customer().from_json_dictionary(j) return None def get_devices_usage(self, deviceGids, instant, scale=Scale.SECOND.value, unit=Unit.KWH.value): """Returns a list of VueDeviceChannelUsage with the total usage of the devices over the specified scale. Note that you may need to scale this to get a rate (1MIN in kw = 60*result)""" if not instant: instant = datetime.datetime.utcnow() gids = deviceGids if isinstance(deviceGids, list): gids = '+'.join(map(str, deviceGids)) url = API_ROOT + API_DEVICES_USAGE.format(deviceGids=gids, instant=_format_time(instant), scale=scale, unit=unit) response = self._get_request(url) response.raise_for_status() channels = [] if response.text: j = response.json() if 'channelUsages' in j: for channel in j['channelUsages']: if channel: channels.append(VueDeviceChannelUsage().from_json_dictionary(channel)) return channels def get_chart_usage(self, channel, start, end, scale=Scale.SECOND.value, unit=Unit.KWH.value): """Gets the usage over a given time period and the start of the measurement period. Note that you may need to scale this to get a rate (1MIN in kw = 60*result)""" if channel.channel_num in ['MainsFromGrid', 'MainsToGrid']: # These is not populated for the special Mains data as of right now return [], start if not start: start = datetime.datetime.utcnow() if not end: end = datetime.datetime.utcnow() url = API_ROOT + API_CHART_USAGE.format(deviceGid=channel.device_gid, channel=channel.channel_num, start=_format_time(start), end=_format_time(end), scale=scale, unit=unit) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() if 'firstUsageInstant' in j: instant = parse(j['firstUsageInstant']) else: instant = start if 'usageList' in j: usage = j['usageList'] else: usage = [] return usage, instant return [], start def get_outlets(self): """ Return a list of outlets linked to the account. """ url = API_ROOT + API_GET_OUTLETS.format(customerGid=self.customer.customer_gid) response = self._get_request(url) response.raise_for_status() outlets = [] if response.text: j = response.json() for raw_outlet in j: outlets.append(OutletDevice().from_json_dictionary(raw_outlet)) return outlets def update_outlet(self, outlet, on=None): """ Primarily to turn an outlet on or off. If the on parameter is not provided then uses the value in the outlet object. If on parameter provided uses the provided value.""" url = API_ROOT + API_OUTLET if on is not None: outlet.outlet_on = on response = self._put_request(url, outlet.as_dictionary()) response.raise_for_status() outlet.from_json_dictionary(response.json()) return outlet def login(self, username=None, password=None, id_token=None, access_token=None, refresh_token=None, token_storage_file=None): """ Authenticates the current user using access tokens if provided or username/password if no tokens available. Provide a path for storing the token data that can be used to reauthenticate without providing the password. Tokens stored in the file are updated when they expire. """ # Use warrant to go through the SRP authentication to get an auth token and refresh token client = boto3.client('cognito-idp', region_name='us-east-2', config=botocore.client.Config(signature_version=botocore.UNSIGNED)) if id_token is not None and access_token is not None and refresh_token is not None: # use existing tokens self.cognito = Cognito(USER_POOL, CLIENT_ID, user_pool_region='us-east-2', id_token=id_token, access_token=access_token, refresh_token=refresh_token) self.cognito.client = client elif username is not None and password is not None: #log in with username and password self.cognito = Cognito(USER_POOL, CLIENT_ID, user_pool_region='us-east-2', username=username) self.cognito.client = client self.cognito.authenticate(password=password) else: raise Exception('No authentication method found. Must supply username/password or id/auth/refresh tokens.') if self.cognito.access_token is not None: if token_storage_file is not None: self.token_storage_file = token_storage_file self._check_token() user = self.cognito.get_user() self.username = user._data['email'] self.customer = self.get_customer_details() self._store_tokens() return self.customer is not None def _check_token(self): if self.cognito.check_token(renew=True): # Token expired and we renewed it. Store new token self._store_tokens() def _store_tokens(self): if not self.token_storage_file: return data = { 'idToken': self.cognito.id_token, 'accessToken': self.cognito.access_token, 'refreshToken': self.cognito.refresh_token } if self.username: data['email'] = self.username with open(self.token_storage_file, 'w') as f: json.dump(data, f, indent=2) def _get_request(self, full_endpoint): if not self.cognito: raise Exception('Must call "login" before calling any API methods.') self._check_token() # ensure our token hasn't expired, refresh if it has headers = {'authtoken': self.cognito.id_token} return requests.get(full_endpoint, headers=headers) def _put_request(self, full_endpoint, body): if not self.cognito: raise Exception('Must call "login" before calling any API methods.') self._check_token() # ensure our token hasn't expired, refresh if it has headers = {'authtoken': self.cognito.id_token} return requests.put(full_endpoint, headers=headers, json=body)
def sign(): signinform = SigninForm(prefix="signin") signupform = SignupForm(prefix="signup") if request.method == 'POST': form = request.form pprint.pprint(form) if request.form['btn'] == 'Signin': # session["active_panel"] = "login-form-link" if signinform.validate_on_submit(): try: auth_cognito = Cognito( cognito_userpool_id, cognito_client_id, user_pool_region=cognito_userpool_region, username=form['signin-username']) auth_cognito.authenticate(password=form['signin-password']) decoded_token = cognitojwt.decode(auth_cognito.id_token, cognito_userpool_region, cognito_userpool_id, cognito_client_id) user = auth_cognito.get_user() credit = user._data['custom:credit'] # except NotAuthorizedException as e: # flash(e.response['Error']['Message']) # return redirect(request.referrer) except Exception as e: if hasattr(e, 'message'): msg = e.message else: msg = str(e) flash(msg, 'error') return redirect(request.referrer) else: flash("Signin Successfully!") user = User() user.id = decoded_token["cognito:username"] user.credit = credit session['credit'] = credit session['expires'] = decoded_token["exp"] session['refresh_token'] = auth_cognito.refresh_token session['id_token'] = auth_cognito.id_token session['access_token'] = auth_cognito.access_token login_user(user, remember=True) next_url = request.args.get('next', 'index').strip("/") print("next_url:{}".format(next_url)) return redirect(url_for(next_url)) else: flash(signinform.errors) return redirect(request.referrer) elif request.form['btn'] == 'Signup': # session["active_panel"] = "register-form-link" if signupform.validate_on_submit(): try: u = Cognito(cognito_userpool_id, cognito_client_id, cognito_userpool_region) u.add_base_attributes(email=form['signup-email']) u.add_custom_attributes(credit='0') u.register(form['signup-username'], form['signup-password']) except Exception as e: if hasattr(e, 'message'): msg = e.message else: msg = str(e) flash(msg, 'error') else: pprint.pprint(session) flash("Finish the signup by confirm link in mailbox") else: flash(signupform.errors, "error") return redirect(request.referrer) return render_template('sign.html', signinform=signinform, signupform=signupform)
class PyEmVue(object): def __init__(self): self.username = None self.token_storage_file = None self.customer = None self.cognito = None def get_devices(self): """Get all devices under the current customer account.""" url = API_ROOT + API_CUSTOMER_DEVICES.format( customerGid=self.customer.customer_gid) response = self._get_request(url) response.raise_for_status() devices = [] if response.text: j = response.json() if 'devices' in j: for dev in j['devices']: devices.append(VueDevice().from_json_dictionary(dev)) if 'devices' in dev: for subdev in dev['devices']: devices.append( VueDevice().from_json_dictionary(subdev)) return devices def populate_device_properties(self, device): """Get details about a specific device""" url = API_ROOT + API_DEVICE_PROPERTIES.format( deviceGid=device.device_gid) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() device.populate_location_properties_from_json(j) return device def get_customer_details(self): """Get details for the current customer.""" url = API_ROOT + API_CUSTOMER.format(email=quote(self.username)) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() return Customer().from_json_dictionary(j) return None def get_total_usage(self, channel, timeFrame=TotalTimeFrame.ALL.value, unit=TotalUnit.WATTHOURS.value): """Get total usage over the provided timeframe for the given device channel.""" url = API_ROOT + API_USAGE_TOTAL.format(deviceGid=channel.device_gid, timeFrame=timeFrame, unit=unit, channels=channel.channel_num) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() if 'usage' in j: return j['usage'] return 0 def get_usage_over_time(self, channel, start, end, scale=Scale.SECOND.value, unit=Unit.WATTS.value): """Get usage over the given time range. Used for primarily for plotting history. Supports time scales less than DAY.""" if scale != Scale.SECOND.value and scale != Scale.MINUTE.value and scale != Scale.MINUTES_15.value and scale != Scale.HOUR.value: raise ValueError( f'Scale of {scale} is invalid, must be 1S, 1MIN, 15MIN, or 1H.' ) url = API_ROOT + API_USAGE_TIME.format(deviceGid=channel.device_gid, startTime=_format_time(start), endTime=_format_time(end), scale=scale, unit=unit, channels=channel.channel_num) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() if 'usage' in j: return j['usage'] return [] def get_usage_over_date_range(self, channel, start, end, scale=Scale.DAY.value, unit=Unit.WATTS.value): """ Get usage over the given date range. Used for primarily for plotting history. Supports time scales of DAY or larger. Note strange behavior with what day is which, first value is for day before start, last value is for day before end, for test timezone of UTC-4. Advise getting a range of days around the desired day and manual verification. """ if scale != Scale.DAY.value and scale != Scale.WEEK.value and scale != Scale.MONTH.value and scale != Scale.YEAR.value: raise ValueError( f'Scale of {scale} is invalid, must be 1D, 1W, 1MON, or 1Y.') url = API_ROOT + API_USAGE_DATE.format(deviceGid=channel.device_gid, startDate=_format_date(start), endDate=_format_date(end), scale=scale, unit=unit, channels=channel.channel_num) response = self._get_request(url) response.raise_for_status() if response.text: j = response.json() if 'usage' in j: return j['usage'] return [] def get_recent_usage(self, scale=Scale.HOUR.value, unit=Unit.WATTS.value): """Get usage over the last 'scale' timeframe.""" now = datetime.datetime.utcnow() return self.get_usage_for_time_scale(now, scale, unit)[0] def get_usage_for_time_scale(self, time, scale=Scale.HOUR.value, unit=Unit.WATTS.value): """ Get usage for the 'scale' timeframe ending at the given time. Only supported for scales less than one day, otherwise time value is ignored and most recent data is given. """ start = time - datetime.timedelta(seconds=1) end = time url = API_ROOT + API_USAGE_DEVICES.format( customerGid=self.customer.customer_gid, scale=scale, unit=unit, startTime=_format_time(start), endTime=_format_time(end)) response = self._get_request(url) response.raise_for_status() channels = [] realStart = None realEnd = None if response.text: j = response.json() if 'start' in j: realStart = parse(j['start']) if 'end' in j: realEnd = parse(j['end']) if 'channels' in j: for channel in j['channels']: channels.append( VuewDeviceChannelUsage().from_json_dictionary(channel)) return channels, realStart, realEnd def get_outlets(self): """ Return a list of outlets linked to the account. """ url = API_ROOT + API_GET_OUTLETS.format( customerGid=self.customer.customer_gid) response = self._get_request(url) response.raise_for_status() outlets = [] if response.text: j = response.json() for raw_outlet in j: outlets.append(OutletDevice().from_json_dictionary(raw_outlet)) return outlets def update_outlet(self, outlet, on=None): """ Primarily to turn an outlet on or off. If the on parameter is not provided then uses the value in the outlet object. If on parameter provided uses the provided value.""" url = API_ROOT + API_OUTLET if on is not None: outlet.outlet_on = on response = self._put_request(url, outlet.as_dictionary()) response.raise_for_status() outlet.from_json_dictionary(response.json()) return outlet def login(self, username=None, password=None, id_token=None, access_token=None, refresh_token=None, token_storage_file=None): """ Authenticates the current user using access tokens if provided or username/password if no tokens available. Provide a path for storing the token data that can be used to reauthenticate without providing the password. Tokens stored in the file are updated when they expire. """ # Use warrant to go through the SRP authentication to get an auth token and refresh token client = boto3.client( 'cognito-idp', region_name='us-east-2', config=botocore.client.Config(signature_version=botocore.UNSIGNED)) if id_token is not None and access_token is not None and refresh_token is not None: # use existing tokens self.cognito = Cognito(USER_POOL, CLIENT_ID, user_pool_region='us-east-2', id_token=id_token, access_token=access_token, refresh_token=refresh_token) self.cognito.client = client elif username is not None and password is not None: #log in with username and password self.cognito = Cognito(USER_POOL, CLIENT_ID, user_pool_region='us-east-2', username=username) self.cognito.client = client self.cognito.authenticate(password=password) else: raise Exception( 'No authentication method found. Must supply username/password or id/auth/refresh tokens.' ) if self.cognito.access_token is not None: if token_storage_file is not None: self.token_storage_file = token_storage_file self._check_token() user = self.cognito.get_user() self.username = user._data['email'] self.customer = self.get_customer_details() self._store_tokens() return self.customer is not None def _check_token(self): if self.cognito.check_token(renew=True): # Token expired and we renewed it. Store new token self._store_tokens() def _store_tokens(self): if not self.token_storage_file: return data = { 'idToken': self.cognito.id_token, 'accessToken': self.cognito.access_token, 'refreshToken': self.cognito.refresh_token } if self.username: data['email'] = self.username with open(self.token_storage_file, 'w') as f: json.dump(data, f, indent=2) def _get_request(self, full_endpoint): if not self.cognito: raise Exception( 'Must call "login" before calling any API methods.') self._check_token( ) # ensure our token hasn't expired, refresh if it has headers = {'authtoken': self.cognito.id_token} return requests.get(full_endpoint, headers=headers) def _put_request(self, full_endpoint, body): if not self.cognito: raise Exception( 'Must call "login" before calling any API methods.') self._check_token( ) # ensure our token hasn't expired, refresh if it has headers = {'authtoken': self.cognito.id_token} return requests.put(full_endpoint, headers=headers, json=body)
def getUserData(self, username, attr_map): u = Cognito(self.USER_POOL_ID, self.CLIENT_ID) user = u.get_user(attr_map) return user
class CognitoAuthTestCase(unittest.TestCase): def setUp(self): self.cognito_user_pool_id = env('COGNITO_USER_POOL_ID') self.app_id = env('COGNITO_APP_ID') self.username = env('COGNITO_TEST_USERNAME') self.password = env('COGNITO_TEST_PASSWORD') self.user = Cognito(self.cognito_user_pool_id, self.app_id, self.username) def tearDown(self): del self.user def test_authenticate(self): self.user.authenticate(self.password) self.assertNotEqual(self.user.access_token, None) self.assertNotEqual(self.user.id_token, None) self.assertNotEqual(self.user.refresh_token, None) def test_logout(self): self.user.authenticate(self.password) self.user.logout() self.assertEqual(self.user.id_token, None) self.assertEqual(self.user.refresh_token, None) self.assertEqual(self.user.access_token, None) @patch('warrant.Cognito', autospec=True) def test_register(self, cognito_user): u = cognito_user(self.cognito_user_pool_id, self.app_id, username=self.username) res = u.register('sampleuser', 'sample4#Password', given_name='Brian', family_name='Jones', name='Brian Jones', email='*****@*****.**', phone_number='+19194894555', gender='Male', preferred_username='******') #TODO: Write assumptions def test_renew_tokens(self): self.user.authenticate(self.password) self.user.renew_access_token() def test_update_profile(self): self.user.authenticate(self.password) self.user.update_profile({'given_name': 'Jenkins'}) u = self.user.get_user() self.assertEquals(u.given_name, 'Jenkins') def test_admin_get_user(self): u = self.user.admin_get_user() self.assertEqual(u.pk, self.username) def test_check_token(self): self.user.authenticate(self.password) self.assertFalse(self.user.check_token()) @patch('warrant.Cognito', autospec=True) def test_validate_verification(self, cognito_user): u = cognito_user(self.cognito_user_pool_id, self.app_id, username=self.username) u.validate_verification('4321') @patch('warrant.Cognito', autospec=True) def test_confirm_forgot_password(self, cognito_user): u = cognito_user(self.cognito_user_pool_id, self.app_id, username=self.username) u.confirm_forgot_password('4553', 'samplepassword') with self.assertRaises(TypeError) as vm: u.confirm_forgot_password(self.password) @patch('warrant.Cognito', autospec=True) def test_change_password(self, cognito_user): u = cognito_user(self.cognito_user_pool_id, self.app_id, username=self.username) u.authenticate(self.password) u.change_password(self.password, 'crazypassword$45DOG') with self.assertRaises(TypeError) as vm: self.user.change_password(self.password) def test_set_attributes(self): u = Cognito(self.cognito_user_pool_id, self.app_id) u._set_attributes({'ResponseMetadata': { 'HTTPStatusCode': 200 }}, {'somerandom': 'attribute'}) self.assertEquals(u.somerandom, 'attribute') def test_admin_authenticate(self): self.user.admin_authenticate(self.password) self.assertNotEqual(self.user.access_token, None) self.assertNotEqual(self.user.id_token, None) self.assertNotEqual(self.user.refresh_token, None)
def user_obj_from_cognito(cognito: Cognito): return cognito.get_user(attr_map={ 'sub': 'id' })