def user(self):
user = UserFactory.build()
copy_user = UserFactory.build(email=user.email, password=user.password)
user.encode_password()
self.session.add(user)
self.session.commit()
return copy_user
def test_model_add_duplicated_email(self):
""" Add a duplicated email """
user = UserFactory()
with self.assertRaises(sqlalchemy.exc.IntegrityError):
repository.new(
User(username=faker.user_name(),
email=user.email,
password=user.password,
role=faker.job()))
def test_model_user_schema_serialize(self):
""" Test UserSchema Serialize """
user_schema = UserSchema()
uf = UserFactory.build()
user = User(username=uf.username,
email=uf.email,
role=uf.role,
password=uf.password)
data = user_schema.dump(user).data
self.assertIsInstance(data, dict)
self.assertEqual(data['username'], uf.username)
self.assertEqual(data['email'], uf.email)
self.assertEqual(data['role'], uf.role)
def test_auth_user_invalid_logout(self):
""" Testing invalid user logout """
user = UserFactory.build()
with self.client:
initial_datetime = datetime.datetime(2017, 1, 1)
other_datetime = datetime.datetime(2017, 1, 2)
with freeze_time(initial_datetime) as frozen_datetime:
helper = UserHelpers(self.client)
helper.register(user)
resp_login = helper.login(user)
# Expire the token
frozen_datetime.move_to(other_datetime)
response = self.client.post(
'/auth/logout',
headers=dict(
Authorization='Bearer ' +
json.loads(resp_login.data.decode())['auth_token']))
data = json.loads(response.data.decode())
self.assertEqual(data['message'],
'Signature Expired, please login again')
self.assertEqual(response.status_code, 401)
def test_auth_login_non_registered_user(self):
""" Test non-registered user login """
user = UserFactory.build()
with self.client:
response = UserHelpers(self.client).login(user)
data = json.loads(response.data.decode())
self.assertEqual(data['message'], 'Nope, try again!')
self.assertEqual(response.status_code, 404)
def test_auth_registration(self):
""" Test user registration """
user = UserFactory.build()
with self.client:
response = UserHelpers(self.client).register(user)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 201)
self.assertEqual(user.username, data['username'])
self.assertEqual(user.email, data['email'])
self.assertEqual(user.role, data['role'])
self.assertTrue(data['auth_token'])
def logged_in_user(client, session):
user = UserFactory.build()
data = dict(email=user.email, password=user.password)
user.encode_password()
session.add(user)
session.commit()
resp = client.post('/users/login',
data=before_login_schema.dumps(data).data,
content_type='application/json')
assert 200 == resp.status_code
return user
def test_model_user_schema_deserialize(self):
""" Test UserSchema De-serialize """
user_schema = UserSchema()
uf = UserFactory.build()
uf_dict = dict(username=uf.username,
email=uf.email,
role=uf.role,
password=uf.password)
data, errors = user_schema.load(uf_dict)
self.assertIsInstance(data, dict)
self.assertEqual(data.get('username'), uf.username)
self.assertEqual(data.get('email'), uf.email)
self.assertEqual(data.get('role'), uf.role)
def test_auth_user_logout(self):
""" Testing user logout """
user = UserFactory.build()
with self.client:
helper = UserHelpers(self.client)
helper.register(user)
resp_login = helper.login(user)
response = self.client.post(
'/auth/logout',
headers=dict(
Authorization='Bearer ' +
json.loads(resp_login.data.decode())['auth_token']))
data = json.loads(response.data.decode())
self.assertEqual(data['message'], 'Successfuly logged out')
self.assertEqual(response.status_code, 200)
def test_auth_check_user(self):
""" Test checking user status """
user = UserFactory.build()
with self.client:
resp_signup = UserHelpers(self.client).register(user)
response = self.client.get(
'/auth/check',
headers=dict(
Authorization='Bearer ' +
json.loads(resp_signup.data.decode())['auth_token']))
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 200)
self.assertEqual(user.username, data['username'])
self.assertEqual(user.email, data['email'])
self.assertEqual(user.role, data['role'])
def test_auth_login_user(self):
""" Test user login """
user = UserFactory.build()
with self.client:
UserHelpers(self.client).register(user)
# Login
response = self.client.post('/auth/login',
data=json.dumps(
dict(username=user.email,
password=user.password)),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(data['message'], 'Login successful')
self.assertTrue(data['auth_token'])
self.assertTrue(response.status_code, 200)
def test_model_add_user(self):
""" Add a user """
user = UserFactory.build()
repository.new(
User(username=user.username,
email=user.email,
role=user.role,
password=user.password))
get_user = User.query.filter_by(username=user.username).first()
self.assertEqual(get_user.email, user.email)
self.assertEqual(get_user.username, user.username)
self.assertTrue(get_user.id)
self.assertTrue(get_user.username)
self.assertTrue(get_user.email)
self.assertTrue(get_user.password)
self.assertTrue(get_user.role)
self.assertTrue(get_user.created_at)
def test_auth_logout_blacklisted_token(self):
""" User logout with blacklisted token """
user = UserFactory.build()
with self.client:
helper = UserHelpers(self.client)
helper.register(user)
resp_login = helper.login(user)
repository.new(
BlacklistToken(
token=json.loads(resp_login.data.decode())['auth_token']))
response = self.client.post(
'/auth/logout',
headers=dict(
Authorization='Bearer ' +
json.loads(resp_login.data.decode())['auth_token']))
data = json.loads(response.data.decode())
self.assertEqual(
data['message'],
'Authentication token is blacklisted. Please login')
self.assertEqual(response.status_code, 401)
def form(self):
user = UserFactory.build()
return user
def form(self, password):
user = UserFactory.build(password=password)
return user
def form(self, email):
user = UserFactory.build(email=email)
return user
