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='******',
owners=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 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 test_pulse_user_multiple_to_single_ownership(self):
self.setup_3_users()
PulseUser.new_user(username="******",
owners=self.all_users,
password="******")
new_emails = self.set_pulse_user_email_list("mick", self.curr_email)
self.assertEquals(new_emails, {self.curr_email})
def test_pulse_user_multiple_to_single_ownership(self):
self.setup_3_users()
PulseUser.new_user(username="******",
owners=self.all_users,
password="******")
new_emails = self.set_pulse_user_email_list("mick", self.curr_email)
self.assertEquals(new_emails, {self.curr_email})
def test_pulse_odd_whitespace_ownership_list(self):
self.setup_3_users()
PulseUser.new_user(username="******",
owners=self.all_users,
password="******")
new_emails = self.set_pulse_user_email_list(
"mick", ", {}, {},{},".format(*self.all_emails))
self.assertEquals(new_emails, set(self.all_emails))
def test_pulse_odd_whitespace_ownership_list(self):
self.setup_3_users()
PulseUser.new_user(username="******",
owners=self.all_users,
password="******")
new_emails = self.set_pulse_user_email_list(
"mick", ", {}, {},{},".format(*self.all_emails))
self.assertEquals(new_emails, set(self.all_emails))
def register_handler():
username = request.form['username']
password = request.form['password']
password_verification = request.form['password-verification']
owners = _clean_owners_str(request.form['owners-list'])
email = session['userinfo']['email']
errors = []
if password != password_verification:
errors.append("Password verification doesn't match the password.")
elif not PulseUser.strong_password(password):
errors.append("Your password must contain a mix of letters and "
"numerical characters and be at least 6 characters "
"long.")
if not re.match('^[a-zA-Z][a-zA-Z0-9._-]*$', username):
errors.append("The submitted username must start with an "
"alphabetical character and contain only alphanumeric "
"characters, periods, underscores, and hyphens.")
if config.reserved_users_regex and re.match(config.reserved_users_regex,
username):
errors.append("The submitted username is reserved. "
+ config.reserved_users_message)
# Checking if a user exists in RabbitMQ OR in our db
try:
user_response = pulse_management.user(username=username)
in_rabbitmq = True
except pulse_management.PulseManagementException:
in_rabbitmq = False
else:
if 'error' in user_response:
in_rabbitmq = False
if (in_rabbitmq or
PulseUser.query.filter(PulseUser.username == username).first()):
errors.append("A user with the same username already exists.")
if errors:
return render_template('register.html', email=email,
signup_errors=errors)
owner_users = list(User.query.filter(User.email.in_(owners)))
# Reject with error message if the owner list is unparse-able or contains
# no users that actualy exist.
if not owner_users:
return register(error="Invalid owners list: {}".format(
request.form['owners-list'] or "None"))
PulseUser.new_user(username, password, owner_users)
return redirect('/profile')
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 update_info():
pulse_username = request.form['pulse-user']
new_password = request.form['new-password']
password_verification = request.form['new-password-verification']
try:
pulse_user = PulseUser.query.filter(
PulseUser.username == pulse_username).one()
except sqlalchemy.orm.exc.NoResultFound:
return profile(messages=["Invalid user."])
if pulse_user.owner != g.user:
return profile(messages=["Invalid user."])
if not new_password:
return profile(messages=["You didn't enter a new password."])
if new_password != password_verification:
return profile(error="Password verification doesn't match the "
"password.")
if not PulseUser.strong_password(new_password):
return profile(error="Your password must contain a mix of "
"letters and numerical characters and be at "
"least 6 characters long.")
pulse_user.change_password(new_password)
return profile(messages=["Password updated for user {0}.".format(
pulse_username)])
def update_info():
pulse_username = request.form['pulse-user']
new_password = request.form['new-password']
password_verification = request.form['new-password-verification']
try:
pulse_user = PulseUser.query.filter(
PulseUser.username == pulse_username).one()
except sqlalchemy.orm.exc.NoResultFound:
return profile(messages=["Invalid user."])
if pulse_user.owner != g.user:
return profile(messages=["Invalid user."])
if not new_password:
return profile(messages=["You didn't enter a new password."])
if new_password != password_verification:
return profile(error="Password verification doesn't match the "
"password.")
if not PulseUser.strong_password(new_password):
return profile(error="Your password must contain a mix of "
"letters and numerical characters and be at "
"least 6 characters long.")
pulse_user.change_password(new_password)
return profile(
messages=["Password updated for user {0}.".format(pulse_username)])
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 update_info():
pulse_username = request.form['pulse-user']
new_password = request.form['new-password']
password_verification = request.form['new-password-verification']
new_owners = _clean_owners_str(request.form['owners-list'])
try:
pulse_user = PulseUser.query.filter(
PulseUser.username == pulse_username).one()
except sqlalchemy.orm.exc.NoResultFound:
return profile(
messages=["Pulse user {} not found.".format(pulse_username)])
if g.user not in pulse_user.owners:
return profile(
messages=["Invalid user: {} is not an owner.".format(g.user.email)])
messages = []
error = None
if new_password:
if new_password != password_verification:
return profile(error="Password verification doesn't match the "
"password.")
if not PulseUser.strong_password(new_password):
return profile(error="Your password must contain a mix of "
"letters and numerical characters and be at "
"least 6 characters long.")
pulse_user.change_password(new_password)
messages.append("Password updated for user {0}.".format(
pulse_username))
# Update the owners list, if needed.
old_owners = {user.email for user in pulse_user.owners}
if new_owners and new_owners != old_owners:
# The list was changed. Do an update.
new_owner_users = list(User.query.filter(User.email.in_(new_owners)))
if new_owner_users:
# At least some of the new owners are real users in the db.
pulse_user.owners = new_owner_users
db_session.commit()
updated_owners = {user.email for user in new_owner_users}
invalid_owners = sorted(new_owners - updated_owners)
if invalid_owners:
error = "Some user emails not found: {}".format(
', '.join(invalid_owners))
else:
messages = ["Email list updated."]
else:
error = ("Invalid owners: "
"Must be a comma-delimited list of existing user emails.")
if not error and not messages:
messages = ["No info updated."]
return profile(messages=messages, error=error)
def register_handler():
username = request.form['username']
password = request.form['password']
password_verification = request.form['password-verification']
email = session['email']
errors = []
if password != password_verification:
errors.append("Password verification doesn't match the password.")
elif not PulseUser.strong_password(password):
errors.append(
"Your password must contain a mix of letters and "
"numerical characters and be at least 6 characters long.")
if not re.match('^[a-zA-Z][a-zA-Z0-9._-]*$', username):
errors.append("The submitted username must start with an "
"alphabetical character and contain only alphanumeric "
"characters, periods, underscores, and hyphens.")
# Checking if a user exists in RabbitMQ OR in our db
try:
user_response = pulse_management.user(username=username)
in_rabbitmq = True
except pulse_management.PulseManagementException:
in_rabbitmq = False
else:
if 'error' in user_response:
in_rabbitmq = False
if (in_rabbitmq
or PulseUser.query.filter(PulseUser.username == username).first()):
errors.append("A user with the same username already exists.")
if errors:
return render_template('register.html',
email=email,
signup_errors=errors)
PulseUser.new_user(username, password, g.user)
return redirect('/profile')
def register_handler():
username = request.form['username']
password = request.form['password']
password_verification = request.form['password-verification']
email = session['email']
errors = []
if password != password_verification:
errors.append("Password verification doesn't match the password.")
elif not PulseUser.strong_password(password):
errors.append("Your password must contain a mix of letters and "
"numerical characters and be at least 6 characters long.")
if not re.match('^[a-zA-Z][a-zA-Z0-9._-]*$', username):
errors.append("The submitted username must start with an "
"alphabetical character and contain only alphanumeric "
"characters, periods, underscores, and hyphens.")
# Checking if a user exists in RabbitMQ OR in our db
try:
user_response = pulse_management.user(username=username)
in_rabbitmq = True
except pulse_management.PulseManagementException:
in_rabbitmq = False
else:
if 'error' in user_response:
in_rabbitmq = False
if (in_rabbitmq or
PulseUser.query.filter(PulseUser.username == username).first()):
errors.append("A user with the same username already exists.")
if errors:
return render_template('register.html', email=email,
signup_errors=errors)
PulseUser.new_user(username, password, g.user)
return redirect('/profile')
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,
create_rabbitmq_user=False)
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)
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='******',
owners=user,
create_rabbitmq_user=False)
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)
