def setUp(self): global pulse_cfg self.proc = None self.publisher = None self.guardian = PulseGuardian(warn_queue_size=TEST_WARN_SIZE, del_queue_size=TEST_DELETE_SIZE, emails=False) dbinit.init_and_clear_db() self.consumer_cfg = pulse_cfg.copy() self.consumer_cfg['applabel'] = str(uuid.uuid1()) # Configure/create the test user to be used for message consumption. self.consumer_cfg['user'] = CONSUMER_USER self.consumer_cfg['password'] = CONSUMER_PASSWORD self.user = User.new_user(email=CONSUMER_EMAIL, admin=False) # As a default owner for pulse_user in some tests where an owner is not # provided. self.admin = User.new_user(email=ADMIN_EMAIL, admin=True) db_session.add(self.user) db_session.commit() self.pulse_user = PulseUser.new_user( username=CONSUMER_USER, password=CONSUMER_PASSWORD, owners=self.user) db_session.add(self.pulse_user) db_session.commit()
def dummy_data(): # Dummy test users User.new_user(email='*****@*****.**') users = User.query.all() for i in xrange(4): RabbitMQAccount.new_user( username='******'.format(i), password='******', owners=users[0]) rabbitmq_accounts = RabbitMQAccount.query.all() # And some dummy queues dummy_queue = Queue(name='dummy-empty-queue', size=0, owner=rabbitmq_accounts[0]) db_session.add(dummy_queue) db_session.commit() dummy_queue = Queue(name='dummy-non-empty-queue', size=config.warn_queue_size/5, owner=rabbitmq_accounts[0]) db_session.add(dummy_queue) db_session.commit() dummy_queue = Queue(name='dummy-warning-queue', size=config.warn_queue_size + 1, owner=rabbitmq_accounts[1]) db_session.add(dummy_queue) db_session.commit() dummy_queue = Queue(name='dummy-deletion-queue', size=int(config.del_queue_size * 1.2), owner=rabbitmq_accounts[2]) db_session.add(dummy_queue) db_session.commit() # Test admin user User.new_user(email='*****@*****.**', admin=True) logger.info('Finished generating dummy data.')
def dummy_data(): # Dummy test users User.new_user(email='*****@*****.**') users = User.query.all() for i in xrange(4): PulseUser.new_user( username='******'.format(i), password='******', owner=users[0]) pulse_users = PulseUser.query.all() # And some dummy queues dummy_queue = Queue(name='dummy-empty-queue', size=0, owner=pulse_users[0]) db_session.add(dummy_queue) db_session.commit() dummy_queue = Queue(name='dummy-non-empty-queue', size=config.warn_queue_size/5, owner=pulse_users[0]) db_session.add(dummy_queue) db_session.commit() dummy_queue = Queue(name='dummy-warning-queue', size=config.warn_queue_size + 1, owner=pulse_users[1]) db_session.add(dummy_queue) db_session.commit() dummy_queue = Queue(name='dummy-deletion-queue', size=int(config.del_queue_size * 1.2), owner=pulse_users[2]) db_session.add(dummy_queue) db_session.commit() # Test admin user User.new_user(email='*****@*****.**', admin=True) logger.info('Finished generating dummy data.')
def setUp(self): global pulse_cfg self.proc = None self.publisher = None self.guardian = PulseGuardian(warn_queue_size=TEST_WARN_SIZE, del_queue_size=TEST_DELETE_SIZE, emails=False) dbinit.init_and_clear_db() self.consumer_cfg = pulse_cfg.copy() self.consumer_cfg['applabel'] = str(uuid.uuid1()) # Configure/create the test user to be used for message consumption. self.consumer_cfg['user'] = CONSUMER_USER self.consumer_cfg['password'] = CONSUMER_PASSWORD self.user = User.new_user(email=CONSUMER_EMAIL, admin=False) # As a default owner for rabbitmq_account in some tests where an owner # is not provided. self.admin = User.new_user(email=ADMIN_EMAIL, admin=True) db_session.add(self.user) db_session.commit() self.rabbitmq_account = RabbitMQAccount.new_user( username=CONSUMER_USER, password=CONSUMER_PASSWORD, owners=self.user) db_session.add(self.rabbitmq_account) db_session.commit()
def setup_3_users(self): mif = "*****@*****.**" maf = "*****@*****.**" self.curr_email = CONSUMER_EMAIL self.all_emails = [mif, maf, self.curr_email] mif_u = User.new_user(email=mif, admin=False) maf_u = User.new_user(email=maf, admin=False) self.curr_user = User.new_user(email=self.curr_email, admin=False) self.all_users = [mif_u, maf_u, self.curr_user]
def setUp(self): global pulse_cfg self.proc = None self.publisher = None self.guardian = PulseGuardian(warn_queue_size=TEST_WARN_SIZE, del_queue_size=TEST_DELETE_SIZE, emails=False) dbinit.init_and_clear_db() self.consumer_cfg = pulse_cfg.copy() self.consumer_cfg['applabel'] = str(uuid.uuid1()) # Configure/create the test user to be used for message consumption. self.consumer_cfg['user'] = CONSUMER_USER self.consumer_cfg['password'] = CONSUMER_PASSWORD self.user = User.new_user(email=CONSUMER_EMAIL, admin=False) db_session.add(self.user) db_session.commit() self.pulse_user = PulseUser.new_user(username=CONSUMER_USER, password=CONSUMER_PASSWORD, owner=self.user) db_session.add(self.pulse_user) db_session.commit()
def callback_handling(): """ Callback from Auth0 Auth0 will call back to this endpoint once it has acquired a user in some capacity (from Google, or their email). Here we verify that what we got back is consistent with Auth0, then match that against our internal DB and either find the user, or create it. """ # Validate what we got in the request against the Auth0 backend. code = request.args.get('code') json_header = {'content-type': 'application/json'} token_url = "https://{domain}/oauth/token".format(domain=config.auth0_domain) token_payload = { 'client_id': config.auth0_client_id, 'client_secret': config.auth0_client_secret, 'redirect_uri': config.auth0_callback_url, 'code': code, 'grant_type': 'authorization_code' } token_info = requests.post(token_url, data=json.dumps(token_payload), headers=json_header).json() user_url = "https://{domain}/userinfo?access_token={access_token}".format( domain=config.auth0_domain, access_token=token_info['access_token']) resp = requests.get(user_url) # Failure to authenticate is handled in the Auth0 lock, so if the user # say, gives the wrong code for their email, the Auth0 lock will notify # them. We don't get a response in the callback here until the user has # satisfied Auth0. The only error we will see is if we can't reach Auth0 # for verification. if resp.ok: # Parse the response user_info = resp.json() # find the user in our DB, or create it. email = user_info['email'] session['email'] = email session['logged_in'] = True user = User.query.filter(User.email == email).first() if user is None: user = User.new_user(email=email) if user.pulse_users: return redirect('/') return redirect('/register') # Oops, something failed. Abort. error_msg = "Error verifying with Auth0 ({})".format(config.auth0_domain) logging.error(error_msg) logging.error(resp.text) # Add this message to the "flash message" list so that the '/' template # can display it. flash(error_msg) return redirect('/')
def auth_handler(): # The request has to have an assertion for us to verify if 'assertion' not in request.form: return jsonify(ok=False, message="Assertion parameter missing") # Send the assertion to Mozilla's verifier service. data = dict(assertion=request.form['assertion'], audience=config.persona_audience) resp = requests.post(config.persona_verifier, data=data, verify=True) # Did the verifier respond? if resp.ok: # Parse the response verification_data = resp.json() if verification_data['status'] == 'okay': email = verification_data['email'] session['email'] = email session['logged_in'] = True user = User.query.filter(User.email == email).first() if user is None: user = User.new_user(email=email) if user.pulse_users: return jsonify(ok=True, redirect='/') return jsonify(ok=True, redirect='/register') # Oops, something failed. Abort. error_msg = "Couldn't connect to the Persona verifier ({0})".format( config.persona_verifier) logging.error(error_msg) return jsonify(ok=False, message=error_msg)
def test_user(self): user = User.new_user(email='*****@*****.**', admin=False) db_session.add(user) db_session.commit() rabbitmq_account = RabbitMQAccount.new_user(username='******', password='******', owners=user, create_rabbitmq_user=False) db_session.add(rabbitmq_account) db_session.commit() self.assertTrue(user in User.query.all()) # Emails are normalized by putting them lower-case self.assertEqual( User.query.filter(User.email == '*****@*****.**').first(), user) self.assertEqual( RabbitMQAccount.query.filter( RabbitMQAccount.username == 'dummy').first(), rabbitmq_account) self.assertEqual( RabbitMQAccount.query.filter( RabbitMQAccount.username == 'DUMMY').first(), None)
def test_user_set_admin(self): user = User.new_user(email='*****@*****.**', admin=False) db_session.add(user) db_session.commit() user = User.query.filter(User.email == '*****@*****.**').first() user.set_admin(True) userDb = User.query.filter(User.email == '*****@*****.**').first() self.assertTrue(userDb.admin)
def load_fake_account(fake_account): """Load fake user and setup session.""" # Set session user. session['userinfo'] = {'email': fake_account} session['fake_account'] = True # Check if user already exists in the database, creating it if not. g.user = User.query.filter(User.email == fake_account).first() if g.user is None: g.user = User.new_user(email=fake_account)
def load_user(): """Loads the currently logged-in user (if any) to the request context.""" # Check if fake account is set and load user. if fake_account: load_fake_account(fake_account) return email = session.get('email') if not email: g.user = None return g.user = User.query.filter(User.email == session.get('email')).first() if not g.user: g.user = User.new_user(email=email)
def setUp(self): global pulse_cfg self.proc = None self.publisher = None self.management_api = PulseManagementAPI( management_url='http://{}:{}/api'.format( pulse_cfg['host'], pulse_cfg['management_port']), user=pulse_cfg['user'], password=pulse_cfg['password'] ) self.guardian = PulseGuardian(self.management_api, warn_queue_size=TEST_WARN_SIZE, del_queue_size=TEST_DELETE_SIZE, emails=False) # Hack in a test config. dbinit.pulse_management = self.management_api dbinit.init_and_clear_db() self.consumer_cfg = pulse_cfg.copy() self.consumer_cfg['applabel'] = str(uuid.uuid1()) # Configure/create the test user to be used for message consumption. self.consumer_cfg['user'] = CONSUMER_USER self.consumer_cfg['password'] = CONSUMER_PASSWORD self.user = User.new_user(email=CONSUMER_EMAIL, admin=False) db_session.add(self.user) db_session.commit() self.pulse_user = PulseUser.new_user( username=CONSUMER_USER, password=CONSUMER_PASSWORD, owner=self.user, management_api=self.management_api) db_session.add(self.pulse_user) db_session.commit()
def test_user(self): user = User.new_user(email='*****@*****.**', admin=False) db_session.add(user) db_session.commit() pulse_user = PulseUser.new_user(username='******', password='******', owner=user, management_api=None) db_session.add(pulse_user) db_session.commit() self.assertTrue(user in User.query.all()) # Emails are normalized by putting them lower-case self.assertEqual( User.query.filter(User.email == '*****@*****.**').first(), user) self.assertEqual( PulseUser.query.filter(PulseUser.username == 'dummy').first(), pulse_user) self.assertEqual( PulseUser.query.filter(PulseUser.username == 'DUMMY').first(), None)