def test_login_required_for_protected_routes(self):
"""Test for route protection."""
un_protected = get_json(self.client.get('/'))
self.assertEqual(un_protected['message'], 'Hello World!')
protected = self.client.get('/protected')
self.assertEqual(protected.status_code, 401)
self.login()
protected = self.client.get('/protected')
result = get_json(protected)
self.assertEqual(protected.status_code, 200)
self.assertEqual(result['message'], 'You are logged-in.')
def test_search_movies_by_name(self):
"""Test searching for movies by name."""
movie1 = self.get_first_movie()
res = self.client.get('/movies?q={}'.format(movie1['name']))
assert res.status_code == 200
result = get_json(res)
assert result[0] == movie1
def test_get_a_movie(self):
"""Test getting a particular movie."""
movie1 = self.get_first_movie()
res = self.client.get('/movies/1')
assert res.status_code == 200
result = get_json(res)
assert result == movie1
def test_delete_user(self):
"""Test that a user can delete his/her account."""
self.login()
res = self.client.delete('/users', data=user1)
result = get_json(res)
self.assertEqual(res.status_code, 200)
self.assertEqual(result['message'], 'Your account has been deleted.')
def test_get_movies(self):
"""Test getting all movies."""
res = self.client.get('/movies')
assert res.status_code == 200
result = get_json(res)
assert len(result) > 1
self.movie1 = result[0]
def test_user_login(self):
"""Test for user login."""
self.register()
login_res = self.client.post('/users/login', data=user1)
result = get_json(login_res)
self.assertEqual(result['message'], "Login successful.")
self.assertEqual(login_res.status_code, 200)
def test_only_authorized_user_can_delete_account(self):
"""Test that only a logged-in user can delete his/her account."""
self.login()
res = self.client.delete('/users')
result = get_json(res)
self.assertEqual(res.status_code, 403)
self.assertEqual(result['message'], 'Unauthorized.')
def test_invalid_user_registration(self):
"""Test for registration when the user already exists."""
self.register()
res = self.client.post('/users/register', data=user1)
self.assertEqual(res.status_code, 400)
result = get_json(res)
self.assertEqual(result['message'], "Invalid username or password.")
def test_ws_devices(app, client):
domoticz_login = app.config.DOMOTICZ_USERNAME
domoticz_password = to_base64(str(app.config.DOMOTICZ_PASSWORD))
domoticz_password_invalid = to_base64('1234')
with app.app_context():
valid_pin = to_base64(get_pin())
json_payload = {
'pin': valid_pin,
'client': 'Android Google Pixel 3',
'client_uuid': str(uuid.uuid1()),
'login': domoticz_login,
'password': domoticz_password
}
response = post_json(client, 'api/beacon_auth/login', json_payload)
response_json = json_response(response)
assert response.status_code == 200
assert 'access_token' in response_json
access_token = response_json['access_token']
json_payload = {'access_token': access_token}
response = get_json(
client,
'api/system/ws_devices',
headers={'Authorization': 'Bearer {}'.format(access_token)})
assert response.status_code == 200
response_json = json_response(response)
assert response_json
assert type(response_json['wsdevices']) == list
def test_user_logout(self):
"""Test for user login."""
self.login()
logout_res = self.client.post('/users/logout')
result = get_json(logout_res)
self.assertEqual(result['message'], 'Logged out.')
self.assertEqual(logout_res.status_code, 200)
def test_create_category(self):
"""Test for category creation."""
self.login()
res = self.client.post(self.route, data=cat1)
result = get_json(res)
self.assertEqual(res.status_code, 201)
self.assertEqual(result['name'], 'codility')
def test_sort_movies_by_time(self):
"""Test that movies can be sorted by date."""
res = self.client.get('/movies?sort=time')
assert res.status_code == 200
result = get_json(res)
sorted_result = sorted(
result, key=lambda movie: get_earliest_movie_time(movie))
sorted_result_names = [x['name'] for x in sorted_result]
assert [x['name'] for x in result] == sorted_result_names
def test_missing_fields_for_create_algorithm(self):
"""Test for errors related to creating an algorithm."""
self.create_category()
missing_title = {
'content': 'print("hi")',
'category': '1',
'sub_category': 'sorting'
}
res = self.client.post('/', data=missing_title)
assert get_json(res)['message'] == 'Invalid title or category id.'
invalid_category = {
'title': 'Binary Sort',
'content': 'print("hi")',
'category': 'abcd',
'sub_category': 'sorting'
}
res = self.client.post('/', data=invalid_category)
assert get_json(res)['message'] == 'Invalid title or category id.'
def test_get_categories(self):
"""Test that all categories can be retrieved."""
self.login()
add_cat_res = self.client.post(self.route, data=cat2)
self.assertEqual(add_cat_res.status_code, 201)
res = self.client.get(self.route)
result = get_json(res)
self.assertEqual(res.status_code, 200)
self.assertEqual(result[0]['name'], 'hackerrank')
def test_user_invalid_login(self):
"""Test for invalid user login."""
self.register()
wrong_pass_user = {
'email': '*****@*****.**',
'password': '******'
}
login_res = self.client.post('/users/login', data=wrong_pass_user)
result = get_json(login_res)
self.assertEqual(result['message'], "Invalid username or password.")
self.assertEqual(login_res.status_code, 401)
def test_algorithm_author_can_update_or_delete(self):
"""Test only the owner can update and delete an algorithm."""
self.create_algorithm()
self.logout()
res = self.client.post('/users/register', data=user2)
assert res.status_code == 201
login_res = self.client.post('/users/login', data=user2)
assert login_res.status_code == 200
update = self.client.put('/1', data=algo2)
assert update.status_code == 403
assert get_json(update)['message'] == 'Unauthorized.'
def test_invalid_id_for_get_update_and_delete_of_category(self):
"""Return 404 if item does not exist."""
self.login()
res = self.client.get(self.route + '/22')
assert res.status_code == 404
assert get_json(res)['message'] == 'Category does not exist.'
res = self.client.put(self.route + '/22', data=cat2)
assert res.status_code == 404
res = self.client.delete(self.route + '/22')
assert res.status_code == 404
def test_login_required_to_create_delete_or_update_algorithm(self):
"""Ensure that the user is logged before creating an algorithm."""
res = self.client.post('/', data=algo1)
assert res.status_code == 401
assert get_json(res)['message'] == 'Login required.'
self.create_algorithm()
self.logout()
res = self.client.put('/1', data=algo1)
assert res.status_code == 401
res = self.client.delete('/1', data=algo1)
assert res.status_code == 401
def test_only_admin_can_create_update_or_delete_category(self):
"""Test that only the Admin can create, update or delete category."""
res = self.client.post('/users/register', data=user1)
self.assertEqual(res.status_code, 201)
login_res = self.client.post('/users/login', data=user1)
self.assertEqual(login_res.status_code, 200)
res = self.client.post(self.route, data=cat1)
assert res.status_code == 403
assert get_json(res)['message'] == 'Unauthorized.'
self.create_category()
self.client.post('/users/logot')
self.client.post('/users/login', data=user1)
res = self.client.put(self.route + '/1', data=cat2)
assert res.status_code == 403
res = self.client.delete(self.route + '/1')
assert res.status_code == 403
def test_sort_movies_by_name(self):
"""Test that movies can be sorted by name."""
res = self.client.get('/movies?sort=name')
assert res.status_code == 200
result = get_json(res)
assert result == sorted(result, key=lambda movie: movie['name'])
def test_user_registration(self):
"""Test for successful user registration."""
res = self.client.post('/users/register', data=user1)
result = get_json(res)
self.assertEqual(result['message'], "Registration successful.")
self.assertEqual(res.status_code, 201)
def test_delete_category(self):
"""Test deleting a category."""
self.create_category()
res = self.client.delete(self.route + '/1')
assert res.status_code == 200
assert get_json(res)['message'] == "Category successfully deleted."
def test_update_category(self):
"""Test updating a category."""
self.create_category()
res = self.client.put(self.route + '/1', data=cat2)
assert res.status_code == 200
assert get_json(res)['name'] == 'hackerrank'
def test_get_category(self):
"""Test that a category can be retrieved."""
self.create_category()
res = self.client.get(self.route + '/1')
assert res.status_code == 200
assert get_json(res)['name'] == 'codility'
def test_invalid_create_category(self):
"""Check invalid user inputs."""
self.create_category()
res = self.client.post(self.route, data=cat1)
assert res.status_code == 409
assert get_json(res)['message'] == 'Category already exists.'
def test_get_invalid_movie(self):
"""Test getting a non-existent movie"""
res = self.client.get('/movies/3000000')
assert res.status_code == 404
result = get_json(res)
assert result['message'] == 'Movie not found.'
def get_first_movie(self):
"""Gets the first movie in database for testing."""
return get_json(self.client.get('/movies'))[0]
