def factory(names):
for name in names:
if isinstance(name, list):
name, email = name
else:
email = '*****@*****.**' % name
User.create_normal(
name, faker.password(), email=email,
is_active=True)
def test_get_all_normal(db, user_foo):
assert User.get_all_normal() == [user_foo]
user_bar = User.create_application('base.bar')
user_baz = User.create_normal('baz', '-', '*****@*****.**', is_active=True)
user_too = User.create_normal('too', '-', '*****@*****.**', is_active=False)
assert User.get_all_normal() == [user_foo, user_baz]
assert user_bar not in User.get_all_normal()
assert user_too not in User.get_all_normal()
def test_get_team_application_token_with_malformed_user(
client, db, test_team, test_application, admin_user, admin_token,
faker):
"""The username and email prefix are not inconsistent."""
User.create_normal('foobar',
faker.uuid4()[:8], '*****@*****.**', True)
r = client.post('/api/team/%s/application/%s/token' %
(test_team.team_name, test_application.application_name),
data={'owner_email': '*****@*****.**'},
headers={'Authorization': admin_token})
assert_response_ok(r)
def test_create_normal(db):
user = User.create_normal('water', 'foobar', '*****@*****.**')
assert user.username == 'water'
assert user.check_password('foobar')
assert not user.check_password('foobaz')
assert not user.is_active
assert user.is_admin is False
assert user.is_application is False
with raises(NameOccupiedError):
User.create_normal('water', 'foobaz', '*****@*****.**')
assert db.query(
User.email).filter_by(username='******').scalar() == '*****@*****.**'
def test_get_multi_by_index(faker, action):
assert AuditLog.get_multi_by_index(AuditLog.TYPE_SITE, 0)[:] == []
assert AuditLog.get_multi_by_index(AuditLog.TYPE_TEAM, 0)[:] == []
user = User.create_normal(faker.uuid4(), '-', faker.email())
log = AuditLog.create(user.id, faker.ipv4(), action)
assert AuditLog.get_multi_by_index(AuditLog.TYPE_SITE, 0)[:] == [log]
assert AuditLog.get_multi_by_index(AuditLog.TYPE_TEAM, 0)[:] == []
def ensure(self):
user = (User.get_by_name(self.name) or User.get_by_email(self.email))
if user is None:
password = gen_salt(30)
user = User.create_normal(self.name,
password,
self.email,
is_active=True)
deliver_email(EmailTemplate.SIGNUP, user.email, {
'username': user.username,
'password': password,
})
return user
def test_get_application_token_with_malformed_application(
client, faker, capsys, db, test_team, admin_token):
_application = Application.create(faker.uuid4()[:8], test_team.id)
_user = User.get_by_name(_application.application_name)
with DBSession() as session:
session.delete(_user)
session.commit()
_user = User.create_normal(_application.application_name,
'-',
is_active=True)
r = client.post('/api/application/%s/token' %
_application.application_name,
headers={'Authorization': admin_token})
assert r.status_code == 400
assert r.json['status'] == 'BadRequest'
assert r.json['message'] == ('malformed application: %s' %
_application.application_name)
assert r.json['data'] is None
def post(self):
"""Creates a new user with your site admin authority.
We will send you an email of random password if don't specify password
explicitly.
:form username: The username of new user.
:form password: The optional password of new user.
:form email: The email of new user.
:<header Authorization: Huskar Token (See :ref:`token`)
:status 400: The username is used or the format is invalid.
:status 200: The new user is created successfully.
"""
g.auth.require_admin('only admin can add users')
username = request.form['username'].strip()
password = request.form.get('password', gen_salt(30))
is_generated_password = '******' not in request.form
email = request.form['email'].strip()
validate_fields(user_schema, {'username': username, 'email': email})
user = User.get_by_name(username)
if user:
abort(400, u'{0} is used username'.format(username))
try:
user = User.create_normal(username,
password,
email,
is_active=True)
except NameOccupiedError:
abort(400, u'User %s has been archived' % username)
audit_log.emit(audit_log.types.CREATE_USER, user=user)
if is_generated_password:
deliver_email(EmailTemplate.SIGNUP, user.email, {
'username': user.username,
'password': password,
})
return api_response()
def test_prefetch_audit_log(faker, action):
users = [
User.create_normal(faker.uuid4()[:8], '-', faker.email())
for _ in xrange(10)]
audit_logs = [
AuditLog.create(user.id, faker.ipv4(), action) for user in users]
rollback_logs = [
AuditLog.create(
audit.user_id, faker.ipv4(), action, rollback_to=audit.id)
for audit in audit_logs]
ids = [audit.id for audit in audit_logs + rollback_logs]
fetched_logs = AuditLog.get_multi_and_prefetch(ids)
for index, audit in enumerate(fetched_logs[:len(audit_logs)]):
assert audit.__dict__['user'] is users[index]
assert 'rollback_to' not in audit.__dict__
assert audit.user is users[index]
assert audit.rollback_to is None
for index, audit in enumerate(fetched_logs[len(audit_logs):]):
assert audit.__dict__['user'] is users[index]
assert audit.__dict__['rollback_to'] is audit_logs[index]
assert audit.user is users[index]
assert audit.rollback_to is audit_logs[index]
def admin_user(db):
admin_user = User.create_normal('admin', password='******', is_active=True)
admin_user.grant_admin()
return admin_user
def user():
return User.create_normal('foo', '-', '*****@*****.**')
def test_user(faker):
email = faker.safe_email()
username = email.split('@', 1)[0]
password = faker.password()
return User.create_normal(username, password, email, is_active=True)
