Alexander/FitTrackee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

API - replace 'Activity' with 'Workout' - #58

Browse Source
This commit is contained in:
Sam
2021-01-10 11:16:43 +01:00
parent 24ee5bbcfa
commit 3a80e01cc2
70 changed files with 2746 additions and 2511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
fittrackee/tests/workouts/__init__.py Normal file
View File

986
fittrackee/tests/workouts/test_records_api.py Normal file
View File

@ -0,0 +1,986 @@
import json
from fittrackee.users.models import User
from fittrackee.workouts.models import Sport, Workout
from flask import Flask
class TestGetRecords:
def test_it_gets_records_for_authenticated_user(
self,
app: Flask,
user_1: User,
user_2: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
workout_cycling_user_1: Workout,
workout_cycling_user_2: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Mon, 01 Jan 2018 00:00:00 GMT'
== data['data']['records'][0]['workout_date']
)
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert (
workout_cycling_user_1.short_id
== data['data']['records'][0]['workout_id']
)
assert 'AS' == data['data']['records'][0]['record_type']
assert 'value' in data['data']['records'][0]
assert (
'Mon, 01 Jan 2018 00:00:00 GMT'
== data['data']['records'][1]['workout_date']
)
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert (
workout_cycling_user_1.short_id
== data['data']['records'][1]['workout_id']
)
assert 'FD' == data['data']['records'][1]['record_type']
assert 'value' in data['data']['records'][1]
assert (
'Mon, 01 Jan 2018 00:00:00 GMT'
== data['data']['records'][2]['workout_date']
)
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert (
workout_cycling_user_1.short_id
== data['data']['records'][2]['workout_id']
)
assert 'LD' == data['data']['records'][2]['record_type']
assert 'value' in data['data']['records'][2]
assert (
'Mon, 01 Jan 2018 00:00:00 GMT'
== data['data']['records'][3]['workout_date']
) # noqa
assert 'test' == data['data']['records'][3]['user']
assert sport_1_cycling.id == data['data']['records'][3]['sport_id']
assert (
workout_cycling_user_1.short_id
== data['data']['records'][3]['workout_id']
)
assert 'MS' == data['data']['records'][3]['record_type']
assert 'value' in data['data']['records'][3]
def test_it_gets_no_records_if_user_has_no_workout(
self,
app: Flask,
user_1: User,
user_2: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
workout_cycling_user_2: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 0
def test_it_gets_no_records_if_workout_has_zero_value(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=0,
workout_date='2018-05-14 14:05',
distance=0,
title='Workout test',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 0
def test_it_gets_updated_records_after_workouts_post_and_patch(
self, app: Flask, user_1: User, sport_1_cycling: Sport
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3600,
workout_date='2018-05-14 14:05',
distance=7,
title='Workout test 1',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_1_short_id = data['data']['workouts'][0]['id']
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_1_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 7.0 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_1_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_1_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:00:00' == data['data']['records'][2]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][3]['workout_date']
) # noqa
assert 'test' == data['data']['records'][3]['user']
assert sport_1_cycling.id == data['data']['records'][3]['sport_id']
assert workout_1_short_id == data['data']['records'][3]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 7.0 == data['data']['records'][3]['value']
# Post workout with lower duration (same sport)
# => 2 new records: Average speed and Max speed
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3000,
workout_date='2018-05-15 14:05',
distance=7,
title='Workout test 2',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_2_short_id = data['data']['workouts'][0]['id']
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Tue, 15 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_2_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 8.4 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_1_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_1_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:00:00' == data['data']['records'][2]['value']
assert (
'Tue, 15 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_2_short_id == data['data']['records'][0]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 8.4 == data['data']['records'][3]['value']
# Post workout with no new records
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3500,
workout_date='2018-05-16 14:05',
distance=6.5,
title='Workout test 3',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_3_short_id = data['data']['workouts'][0]['id']
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Tue, 15 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_2_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 8.4 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_1_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_1_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:00:00' == data['data']['records'][2]['value']
assert (
'Tue, 15 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_2_short_id == data['data']['records'][0]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 8.4 == data['data']['records'][3]['value']
# Edit last workout
# 1 new record: Longest duration
client.patch(
f'/api/workouts/{workout_3_short_id}',
content_type='application/json',
data=json.dumps(dict(duration=4000)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Tue, 15 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_2_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 8.4 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_1_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Wed, 16 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_3_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:06:40' == data['data']['records'][2]['value']
assert (
'Tue, 15 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_2_short_id == data['data']['records'][0]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 8.4 == data['data']['records'][3]['value']
# delete workout 2 => AS and MS record update
client.delete(
f'/api/workouts/{workout_2_short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_1_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 7.0 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_1_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Wed, 16 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_3_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:06:40' == data['data']['records'][2]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][3]['workout_date']
) # noqa
assert 'test' == data['data']['records'][3]['user']
assert sport_1_cycling.id == data['data']['records'][3]['sport_id']
assert workout_1_short_id == data['data']['records'][3]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 7.0 == data['data']['records'][3]['value']
# add a workout with the same data as workout 1 except with a
# later date => no change in record
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3600,
workout_date='2018-05-20 14:05',
distance=7,
title='Workout test 4',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_4_short_id = data['data']['workouts'][0]['id']
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_1_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 7.0 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_1_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Wed, 16 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_3_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:06:40' == data['data']['records'][2]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][3]['workout_date']
) # noqa
assert 'test' == data['data']['records'][3]['user']
assert sport_1_cycling.id == data['data']['records'][3]['sport_id']
assert workout_1_short_id == data['data']['records'][3]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 7.0 == data['data']['records'][3]['value']
# add a workout with the same data as workout 1 except with
# an earlier date
# => record update (workout 5 replace workout 1)
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3600,
workout_date='2018-05-14 08:05',
distance=7,
title='Workout test 5',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_5_short_id = data['data']['workouts'][0]['id']
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 4
assert (
'Mon, 14 May 2018 08:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_5_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 7.0 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 08:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_5_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Wed, 16 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_3_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:06:40' == data['data']['records'][2]['value']
assert (
'Mon, 14 May 2018 08:05:00 GMT'
== data['data']['records'][3]['workout_date']
) # noqa
assert 'test' == data['data']['records'][3]['user']
assert sport_1_cycling.id == data['data']['records'][3]['sport_id']
assert workout_5_short_id == data['data']['records'][3]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 7.0 == data['data']['records'][3]['value']
# delete all workouts - no more records
client.delete(
f'/api/workouts/{workout_1_short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
client.delete(
f'/api/workouts/{workout_3_short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
client.delete(
f'/api/workouts/{workout_4_short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
client.delete(
f'/api/workouts/{workout_5_short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 0
def test_it_gets_updated_records_after_sport_change(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3600,
workout_date='2018-05-14 14:05',
distance=7,
title='Workout test 1',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_1_short_id = data['data']['workouts'][0]['id']
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=2,
duration=3600,
workout_date='2018-05-16 16:05',
distance=20,
title='Workout test 2',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_2_short_id = data['data']['workouts'][0]['id']
client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3000,
workout_date='2018-05-17 17:05',
distance=3,
title='Workout test 3',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
response = client.post(
'/api/workouts/no_gpx',
content_type='application/json',
data=json.dumps(
dict(
sport_id=2,
duration=3000,
workout_date='2018-05-18 18:05',
distance=10,
title='Workout test 4',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
workout_4_short_id = data['data']['workouts'][0]['id']
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 8
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_1_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 7.0 == data['data']['records'][0]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_1_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 7.0 == data['data']['records'][1]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_1_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:00:00' == data['data']['records'][2]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][3]['workout_date']
) # noqa
assert 'test' == data['data']['records'][3]['user']
assert sport_1_cycling.id == data['data']['records'][3]['sport_id']
assert workout_1_short_id == data['data']['records'][3]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 7.0 == data['data']['records'][3]['value']
assert (
'Wed, 16 May 2018 16:05:00 GMT'
== data['data']['records'][4]['workout_date']
) # noqa
assert 'test' == data['data']['records'][4]['user']
assert sport_2_running.id == data['data']['records'][4]['sport_id']
assert workout_2_short_id == data['data']['records'][4]['workout_id']
assert 'AS' == data['data']['records'][4]['record_type']
assert 20.0 == data['data']['records'][4]['value']
assert (
'Wed, 16 May 2018 16:05:00 GMT'
== data['data']['records'][5]['workout_date']
) # noqa
assert 'test' == data['data']['records'][5]['user']
assert sport_2_running.id == data['data']['records'][5]['sport_id']
assert workout_2_short_id == data['data']['records'][5]['workout_id']
assert 'FD' == data['data']['records'][5]['record_type']
assert 20.0 == data['data']['records'][5]['value']
assert (
'Wed, 16 May 2018 16:05:00 GMT'
== data['data']['records'][6]['workout_date']
) # noqa
assert 'test' == data['data']['records'][6]['user']
assert sport_2_running.id == data['data']['records'][6]['sport_id']
assert workout_2_short_id == data['data']['records'][6]['workout_id']
assert 'LD' == data['data']['records'][6]['record_type']
assert '1:00:00' == data['data']['records'][6]['value']
assert (
'Wed, 16 May 2018 16:05:00 GMT'
== data['data']['records'][7]['workout_date']
) # noqa
assert 'test' == data['data']['records'][7]['user']
assert sport_2_running.id == data['data']['records'][7]['sport_id']
assert workout_2_short_id == data['data']['records'][7]['workout_id']
assert 'MS' == data['data']['records'][7]['record_type']
assert 20.0 == data['data']['records'][7]['value']
client.patch(
f'/api/workouts/{workout_2_short_id}',
content_type='application/json',
data=json.dumps(dict(sport_id=1)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
response = client.get(
'/api/records',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['records']) == 8
assert (
'Wed, 16 May 2018 16:05:00 GMT'
== data['data']['records'][0]['workout_date']
) # noqa
assert 'test' == data['data']['records'][0]['user']
assert sport_1_cycling.id == data['data']['records'][0]['sport_id']
assert workout_2_short_id == data['data']['records'][0]['workout_id']
assert 'AS' == data['data']['records'][0]['record_type']
assert 20.0 == data['data']['records'][0]['value']
assert (
'Wed, 16 May 2018 16:05:00 GMT'
== data['data']['records'][1]['workout_date']
) # noqa
assert 'test' == data['data']['records'][1]['user']
assert sport_1_cycling.id == data['data']['records'][1]['sport_id']
assert workout_2_short_id == data['data']['records'][1]['workout_id']
assert 'FD' == data['data']['records'][1]['record_type']
assert 20.0 == data['data']['records'][1]['value']
assert (
'Mon, 14 May 2018 14:05:00 GMT'
== data['data']['records'][2]['workout_date']
) # noqa
assert 'test' == data['data']['records'][2]['user']
assert sport_1_cycling.id == data['data']['records'][2]['sport_id']
assert workout_1_short_id == data['data']['records'][2]['workout_id']
assert 'LD' == data['data']['records'][2]['record_type']
assert '1:00:00' == data['data']['records'][2]['value']
assert (
'Wed, 16 May 2018 16:05:00 GMT'
== data['data']['records'][3]['workout_date']
) # noqa
assert 'test' == data['data']['records'][3]['user']
assert sport_1_cycling.id == data['data']['records'][3]['sport_id']
assert workout_2_short_id == data['data']['records'][3]['workout_id']
assert 'MS' == data['data']['records'][3]['record_type']
assert 20.0 == data['data']['records'][3]['value']
assert (
'Fri, 18 May 2018 18:05:00 GMT'
== data['data']['records'][4]['workout_date']
) # noqa
assert 'test' == data['data']['records'][4]['user']
assert sport_2_running.id == data['data']['records'][4]['sport_id']
assert workout_4_short_id == data['data']['records'][4]['workout_id']
assert 'AS' == data['data']['records'][4]['record_type']
assert 12.0 == data['data']['records'][4]['value']
assert (
'Fri, 18 May 2018 18:05:00 GMT'
== data['data']['records'][5]['workout_date']
) # noqa
assert 'test' == data['data']['records'][5]['user']
assert sport_2_running.id == data['data']['records'][5]['sport_id']
assert workout_4_short_id == data['data']['records'][5]['workout_id']
assert 'FD' == data['data']['records'][5]['record_type']
assert 10.0 == data['data']['records'][5]['value']
assert (
'Fri, 18 May 2018 18:05:00 GMT'
== data['data']['records'][6]['workout_date']
) # noqa
assert 'test' == data['data']['records'][6]['user']
assert sport_2_running.id == data['data']['records'][6]['sport_id']
assert workout_4_short_id == data['data']['records'][6]['workout_id']
assert 'LD' == data['data']['records'][6]['record_type']
assert '0:50:00' == data['data']['records'][6]['value']
assert (
'Fri, 18 May 2018 18:05:00 GMT'
== data['data']['records'][7]['workout_date']
) # noqa
assert 'test' == data['data']['records'][7]['user']
assert sport_2_running.id == data['data']['records'][7]['sport_id']
assert workout_4_short_id == data['data']['records'][7]['workout_id']
assert 'MS' == data['data']['records'][7]['record_type']
assert 12.0 == data['data']['records'][7]['value']

165
fittrackee/tests/workouts/test_records_model.py Normal file
View File

@ -0,0 +1,165 @@
import datetime
from fittrackee.users.models import User
from fittrackee.workouts.models import Record, Sport, Workout
from flask import Flask
class TestRecordModel:
def test_record_model(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
record_ld = Record.query.filter_by(
user_id=workout_cycling_user_1.user_id,
sport_id=workout_cycling_user_1.sport_id,
record_type='LD',
).first()
assert 'test' == record_ld.user.username
assert 1 == record_ld.sport_id
assert 1 == record_ld.workout_id
assert 'LD' == record_ld.record_type
assert '2018-01-01 00:00:00' == str(record_ld.workout_date)
assert '<Record Cycling - LD - 2018-01-01>' == str(record_ld)
record_serialize = record_ld.serialize()
assert 'id' in record_serialize
assert 'user' in record_serialize
assert 'sport_id' in record_serialize
assert 'workout_id' in record_serialize
assert 'record_type' in record_serialize
assert 'workout_date' in record_serialize
assert 'value' in record_serialize
def test_record_model_with_none_value(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
record_ld = Record.query.filter_by(
user_id=workout_cycling_user_1.user_id,
sport_id=workout_cycling_user_1.sport_id,
record_type='LD',
).first()
record_ld.value = None
assert 'test' == record_ld.user.username
assert 1 == record_ld.sport_id
assert 1 == record_ld.workout_id
assert 'LD' == record_ld.record_type
assert '2018-01-01 00:00:00' == str(record_ld.workout_date)
assert '<Record Cycling - LD - 2018-01-01>' == str(record_ld)
assert record_ld.value is None
record_serialize = record_ld.serialize()
assert record_serialize['value'] is None
def test_average_speed_records(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
record_as = Record.query.filter_by(
user_id=workout_cycling_user_1.user_id,
sport_id=workout_cycling_user_1.sport_id,
record_type='AS',
).first()
assert isinstance(record_as.value, float)
assert record_as.value == 10.0
assert record_as._value == 1000
record_serialize = record_as.serialize()
assert record_serialize.get('value') == 10.0
assert isinstance(record_serialize.get('value'), float)
def test_add_farest_distance_records(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
record_fd = Record.query.filter_by(
user_id=workout_cycling_user_1.user_id,
sport_id=workout_cycling_user_1.sport_id,
record_type='FD',
).first()
assert isinstance(record_fd.value, float)
assert record_fd.value == 10.0
assert record_fd._value == 10000
record_serialize = record_fd.serialize()
assert record_serialize.get('value') == 10.0
assert isinstance(record_serialize.get('value'), float)
def test_add_longest_duration_records(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
record_ld = Record.query.filter_by(
user_id=workout_cycling_user_1.user_id,
sport_id=workout_cycling_user_1.sport_id,
record_type='LD',
).first()
assert isinstance(record_ld.value, datetime.timedelta)
assert str(record_ld.value) == '1:00:00'
assert record_ld._value == 3600
record_serialize = record_ld.serialize()
assert record_serialize.get('value') == '1:00:00'
assert isinstance(record_serialize.get('value'), str)
def test_add_longest_duration_records_with_zero(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
record_ld = Record.query.filter_by(
user_id=workout_cycling_user_1.user_id,
sport_id=workout_cycling_user_1.sport_id,
record_type='LD',
).first()
record_ld.value = datetime.timedelta(seconds=0)
assert isinstance(record_ld.value, datetime.timedelta)
assert str(record_ld.value) == '0:00:00'
assert record_ld._value == 0
record_serialize = record_ld.serialize()
assert record_serialize.get('value') == '0:00:00'
assert isinstance(record_serialize.get('value'), str)
def test_max_speed_records_no_value(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
record_ms = Record.query.filter_by(
user_id=workout_cycling_user_1.user_id,
sport_id=workout_cycling_user_1.sport_id,
record_type='MS',
).first()
assert isinstance(record_ms.value, float)
assert record_ms.value == 10.0
assert record_ms._value == 1000
record_serialize = record_ms.serialize()
assert record_serialize.get('value') == 10.0
assert isinstance(record_serialize.get('value'), float)

444
fittrackee/tests/workouts/test_sports_api.py Normal file
View File

@ -0,0 +1,444 @@
import json
from fittrackee.users.models import User
from fittrackee.workouts.models import Sport, Workout
from flask import Flask
expected_sport_1_cycling_result = {
'id': 1,
'label': 'Cycling',
'img': None,
'is_active': True,
}
expected_sport_1_cycling_admin_result = expected_sport_1_cycling_result.copy()
expected_sport_1_cycling_admin_result['has_workouts'] = False
expected_sport_2_running_result = {
'id': 2,
'label': 'Running',
'img': None,
'is_active': True,
}
expected_sport_2_running_admin_result = expected_sport_2_running_result.copy()
expected_sport_2_running_admin_result['has_workouts'] = False
expected_sport_1_cycling_inactive_result = {
'id': 1,
'label': 'Cycling',
'img': None,
'is_active': False,
}
expected_sport_1_cycling_inactive_admin_result = (
expected_sport_1_cycling_inactive_result.copy()
)
expected_sport_1_cycling_inactive_admin_result['has_workouts'] = False
class TestGetSports:
def test_it_gets_all_sports(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.get(
'/api/sports',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 2
assert data['data']['sports'][0] == expected_sport_1_cycling_result
assert data['data']['sports'][1] == expected_sport_2_running_result
def test_it_gets_all_sports_with_inactive_one(
self,
app: Flask,
user_1: User,
sport_1_cycling_inactive: Sport,
sport_2_running: Sport,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.get(
'/api/sports',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 2
assert (
data['data']['sports'][0]
== expected_sport_1_cycling_inactive_result
)
assert data['data']['sports'][1] == expected_sport_2_running_result
def test_it_gets_all_sports_with_admin_rights(
self,
app: Flask,
user_1_admin: User,
sport_1_cycling_inactive: Sport,
sport_2_running: Sport,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.get(
'/api/sports',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 2
assert (
data['data']['sports'][0]
== expected_sport_1_cycling_inactive_admin_result
)
assert (
data['data']['sports'][1] == expected_sport_2_running_admin_result
)
class TestGetSport:
def test_it_gets_a_sport(
self, app: Flask, user_1: User, sport_1_cycling: Sport
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.get(
'/api/sports/1',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 1
assert data['data']['sports'][0] == expected_sport_1_cycling_result
def test_it_returns_404_if_sport_does_not_exist(
self, app: Flask, user_1: User
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.get(
'/api/sports/1',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 404
assert 'not found' in data['status']
assert len(data['data']['sports']) == 0
def test_it_gets_a_inactive_sport(
self, app: Flask, user_1: User, sport_1_cycling_inactive: Sport
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.get(
'/api/sports/1',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 1
assert (
data['data']['sports'][0]
== expected_sport_1_cycling_inactive_result
)
def test_it_get_an_inactive_sport_with_admin_rights(
self, app: Flask, user_1_admin: User, sport_1_cycling_inactive: Sport
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.get(
'/api/sports/1',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 1
assert (
data['data']['sports'][0]
== expected_sport_1_cycling_inactive_admin_result
)
class TestUpdateSport:
def test_it_disables_a_sport(
self, app: Flask, user_1_admin: User, sport_1_cycling: Sport
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.patch(
'/api/sports/1',
content_type='application/json',
data=json.dumps(dict(is_active=False)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 1
assert data['data']['sports'][0]['is_active'] is False
assert data['data']['sports'][0]['has_workouts'] is False
def test_it_enables_a_sport(
self, app: Flask, user_1_admin: User, sport_1_cycling: Sport
) -> None:
sport_1_cycling.is_active = False
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.patch(
'/api/sports/1',
content_type='application/json',
data=json.dumps(dict(is_active=True)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 1
assert data['data']['sports'][0]['is_active'] is True
assert data['data']['sports'][0]['has_workouts'] is False
def test_it_disables_a_sport_with_workouts(
self,
app: Flask,
user_1_admin: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.patch(
'/api/sports/1',
content_type='application/json',
data=json.dumps(dict(is_active=False)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 1
assert data['data']['sports'][0]['is_active'] is False
assert data['data']['sports'][0]['has_workouts'] is True
def test_it_enables_a_sport_with_workouts(
self,
app: Flask,
user_1_admin: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
sport_1_cycling.is_active = False
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.patch(
'/api/sports/1',
content_type='application/json',
data=json.dumps(dict(is_active=True)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['sports']) == 1
assert data['data']['sports'][0]['is_active'] is True
assert data['data']['sports'][0]['has_workouts'] is True
def test_returns_error_if_user_has_no_admin_rights(
self, app: Flask, user_1: User, sport_1_cycling: Sport
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
'/api/sports/1',
content_type='application/json',
data=json.dumps(dict(is_active=False)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 403
assert 'success' not in data['status']
assert 'error' in data['status']
assert 'You do not have permissions.' in data['message']
def test_returns_error_if_payload_is_invalid(
self, app: Flask, user_1_admin: User
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.patch(
'/api/sports/1',
content_type='application/json',
data=json.dumps(dict()),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 400
assert 'error' in data['status']
assert 'Invalid payload.' in data['message']
def test_it_returns_error_if_sport_does_not_exist(
self, app: Flask, user_1_admin: User
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(
dict(email='admin@example.com', password='12345678')
),
content_type='application/json',
)
response = client.patch(
'/api/sports/1',
content_type='application/json',
data=json.dumps(dict(is_active=False)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 404
assert 'not found' in data['status']
assert len(data['data']['sports']) == 0

45
fittrackee/tests/workouts/test_sports_model.py Normal file
View File

@ -0,0 +1,45 @@
from typing import Dict, Optional
from fittrackee.users.models import User
from fittrackee.workouts.models import Sport, Workout
from flask import Flask
class TestSportModel:
@staticmethod
def assert_sport_model(
sport: Sport, is_admin: Optional[bool] = False
) -> Dict:
assert 1 == sport.id
assert 'Cycling' == sport.label
assert '<Sport \'Cycling\'>' == str(sport)
serialized_sport = sport.serialize(is_admin)
assert 1 == serialized_sport['id']
assert 'Cycling' == serialized_sport['label']
assert serialized_sport['is_active'] is True
return serialized_sport
def test_sport_model(self, app: Flask, sport_1_cycling: Sport) -> None:
serialized_sport = self.assert_sport_model(sport_1_cycling)
assert 'has_workouts' not in serialized_sport
def test_sport_model_with_workout(
self,
app: Flask,
sport_1_cycling: Sport,
user_1: User,
workout_cycling_user_1: Workout,
) -> None:
serialized_sport = self.assert_sport_model(sport_1_cycling)
assert 'has_workouts' not in serialized_sport
def test_sport_model_with_workout_as_admin(
self,
app: Flask,
sport_1_cycling: Sport,
user_1: User,
workout_cycling_user_1: Workout,
) -> None:
serialized_sport = self.assert_sport_model(sport_1_cycling, True)
assert serialized_sport['has_workouts'] is True

1082
fittrackee/tests/workouts/test_stats_api.py Normal file
View File

File diff suppressed because it is too large Load Diff

1046
fittrackee/tests/workouts/test_workouts_api_0_get.py Normal file
View File

File diff suppressed because it is too large Load Diff

1366
fittrackee/tests/workouts/test_workouts_api_1_post.py Normal file
View File

File diff suppressed because it is too large Load Diff

691
fittrackee/tests/workouts/test_workouts_api_2_patch.py Normal file
View File

@ -0,0 +1,691 @@
import json
from typing import Dict
from fittrackee.users.models import User
from fittrackee.workouts.models import Sport, Workout
from fittrackee.workouts.utils_id import decode_short_id
from flask import Flask
from .utils import get_random_short_id, post_an_workout
def assert_workout_data_with_gpx(data: Dict, sport_id: int) -> None:
assert 'creation_date' in data['data']['workouts'][0]
assert (
'Tue, 13 Mar 2018 12:44:45 GMT'
== data['data']['workouts'][0]['workout_date']
)
assert 'test' == data['data']['workouts'][0]['user']
assert '0:04:10' == data['data']['workouts'][0]['duration']
assert data['data']['workouts'][0]['ascent'] == 0.4
assert data['data']['workouts'][0]['ave_speed'] == 4.61
assert data['data']['workouts'][0]['descent'] == 23.4
assert data['data']['workouts'][0]['distance'] == 0.32
assert data['data']['workouts'][0]['max_alt'] == 998.0
assert data['data']['workouts'][0]['max_speed'] == 5.12
assert data['data']['workouts'][0]['min_alt'] == 975.0
assert data['data']['workouts'][0]['moving'] == '0:04:10'
assert data['data']['workouts'][0]['pauses'] is None
assert data['data']['workouts'][0]['with_gpx'] is True
records = data['data']['workouts'][0]['records']
assert len(records) == 4
assert records[0]['sport_id'] == sport_id
assert records[0]['workout_id'] == data['data']['workouts'][0]['id']
assert records[0]['record_type'] == 'MS'
assert records[0]['workout_date'] == 'Tue, 13 Mar 2018 12:44:45 GMT'
assert records[0]['value'] == 5.12
assert records[1]['sport_id'] == sport_id
assert records[1]['workout_id'] == data['data']['workouts'][0]['id']
assert records[1]['record_type'] == 'LD'
assert records[1]['workout_date'] == 'Tue, 13 Mar 2018 12:44:45 GMT'
assert records[1]['value'] == '0:04:10'
assert records[2]['sport_id'] == sport_id
assert records[2]['workout_id'] == data['data']['workouts'][0]['id']
assert records[2]['record_type'] == 'FD'
assert records[2]['workout_date'] == 'Tue, 13 Mar 2018 12:44:45 GMT'
assert records[2]['value'] == 0.32
assert records[3]['sport_id'] == sport_id
assert records[3]['workout_id'] == data['data']['workouts'][0]['id']
assert records[3]['record_type'] == 'AS'
assert records[3]['workout_date'] == 'Tue, 13 Mar 2018 12:44:45 GMT'
assert records[3]['value'] == 4.61
class TestEditWorkoutWithGpx:
def test_it_updates_title_for_an_workout_with_gpx(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
gpx_file: str,
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(sport_id=2, title="Workout test")),
headers=dict(Authorization=f'Bearer {token}'),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert sport_2_running.id == data['data']['workouts'][0]['sport_id']
assert data['data']['workouts'][0]['title'] == 'Workout test'
assert_workout_data_with_gpx(data, sport_2_running.id)
def test_it_adds_notes_for_an_workout_with_gpx(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
gpx_file: str,
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(notes="test notes")),
headers=dict(Authorization=f'Bearer {token}'),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert data['data']['workouts'][0]['title'] == 'just a workout'
assert data['data']['workouts'][0]['notes'] == 'test notes'
def test_it_raises_403_when_editing_an_workout_from_different_user(
self,
app: Flask,
user_1: User,
user_2: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
gpx_file: str,
) -> None:
_, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='toto@toto.com', password='87654321')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(sport_id=2, title="Workout test")),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 403
assert 'error' in data['status']
assert 'You do not have permissions.' in data['message']
def test_it_updates_sport(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
gpx_file: str,
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(sport_id=2)),
headers=dict(Authorization=f'Bearer {token}'),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert sport_2_running.id == data['data']['workouts'][0]['sport_id']
assert data['data']['workouts'][0]['title'] == 'just a workout'
assert_workout_data_with_gpx(data, sport_2_running.id)
def test_it_returns_400_if_payload_is_empty(
self, app: Flask, user_1: User, sport_1_cycling: Sport, gpx_file: str
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict()),
headers=dict(Authorization=f'Bearer {token}'),
)
data = json.loads(response.data.decode())
assert response.status_code == 400
assert 'error' in data['status']
assert 'Invalid payload.' in data['message']
def test_it_raises_500_if_sport_does_not_exists(
self, app: Flask, user_1: User, sport_1_cycling: Sport, gpx_file: str
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(sport_id=2)),
headers=dict(Authorization=f'Bearer {token}'),
)
data = json.loads(response.data.decode())
assert response.status_code == 500
assert 'error' in data['status']
assert (
'Error. Please try again or contact the administrator.'
in data['message']
)
class TestEditWorkoutWithoutGpx:
def test_it_updates_an_workout_wo_gpx(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
workout_cycling_user_1: Workout,
) -> None:
workout_short_id = workout_cycling_user_1.short_id
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(
dict(
sport_id=2,
duration=3600,
workout_date='2018-05-15 15:05',
distance=8,
title='Workout test',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert 'creation_date' in data['data']['workouts'][0]
assert (
data['data']['workouts'][0]['workout_date']
== 'Tue, 15 May 2018 15:05:00 GMT'
)
assert data['data']['workouts'][0]['user'] == 'test'
assert data['data']['workouts'][0]['sport_id'] == sport_2_running.id
assert data['data']['workouts'][0]['duration'] == '1:00:00'
assert data['data']['workouts'][0]['title'] == 'Workout test'
assert data['data']['workouts'][0]['ascent'] is None
assert data['data']['workouts'][0]['ave_speed'] == 8.0
assert data['data']['workouts'][0]['descent'] is None
assert data['data']['workouts'][0]['distance'] == 8.0
assert data['data']['workouts'][0]['max_alt'] is None
assert data['data']['workouts'][0]['max_speed'] == 8.0
assert data['data']['workouts'][0]['min_alt'] is None
assert data['data']['workouts'][0]['moving'] == '1:00:00'
assert data['data']['workouts'][0]['pauses'] is None
assert data['data']['workouts'][0]['with_gpx'] is False
assert data['data']['workouts'][0]['map'] is None
assert data['data']['workouts'][0]['weather_start'] is None
assert data['data']['workouts'][0]['weather_end'] is None
assert data['data']['workouts'][0]['notes'] is None
records = data['data']['workouts'][0]['records']
assert len(records) == 4
assert records[0]['sport_id'] == sport_2_running.id
assert records[0]['workout_id'] == workout_short_id
assert records[0]['record_type'] == 'MS'
assert records[0]['workout_date'] == 'Tue, 15 May 2018 15:05:00 GMT'
assert records[0]['value'] == 8.0
assert records[1]['sport_id'] == sport_2_running.id
assert records[1]['workout_id'] == workout_short_id
assert records[1]['record_type'] == 'LD'
assert records[1]['workout_date'] == 'Tue, 15 May 2018 15:05:00 GMT'
assert records[1]['value'] == '1:00:00'
assert records[2]['sport_id'] == sport_2_running.id
assert records[2]['workout_id'] == workout_short_id
assert records[2]['record_type'] == 'FD'
assert records[2]['workout_date'] == 'Tue, 15 May 2018 15:05:00 GMT'
assert records[2]['value'] == 8.0
assert records[3]['sport_id'] == sport_2_running.id
assert records[3]['workout_id'] == workout_short_id
assert records[3]['record_type'] == 'AS'
assert records[3]['workout_date'] == 'Tue, 15 May 2018 15:05:00 GMT'
assert records[3]['value'] == 8.0
def test_it_adds_notes_to_an_workout_wo_gpx(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
workout_short_id = workout_cycling_user_1.short_id
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(notes='test notes')),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert 'creation_date' in data['data']['workouts'][0]
assert (
data['data']['workouts'][0]['workout_date']
== 'Mon, 01 Jan 2018 00:00:00 GMT'
)
assert data['data']['workouts'][0]['user'] == 'test'
assert data['data']['workouts'][0]['sport_id'] == sport_1_cycling.id
assert data['data']['workouts'][0]['duration'] == '1:00:00'
assert data['data']['workouts'][0]['title'] is None
assert data['data']['workouts'][0]['ascent'] is None
assert data['data']['workouts'][0]['ave_speed'] == 10.0
assert data['data']['workouts'][0]['descent'] is None
assert data['data']['workouts'][0]['distance'] == 10.0
assert data['data']['workouts'][0]['max_alt'] is None
assert data['data']['workouts'][0]['max_speed'] == 10.0
assert data['data']['workouts'][0]['min_alt'] is None
assert data['data']['workouts'][0]['moving'] == '1:00:00'
assert data['data']['workouts'][0]['pauses'] is None
assert data['data']['workouts'][0]['with_gpx'] is False
assert data['data']['workouts'][0]['map'] is None
assert data['data']['workouts'][0]['weather_start'] is None
assert data['data']['workouts'][0]['weather_end'] is None
assert data['data']['workouts'][0]['notes'] == 'test notes'
records = data['data']['workouts'][0]['records']
assert len(records) == 4
assert records[0]['sport_id'] == sport_1_cycling.id
assert records[0]['workout_id'] == workout_short_id
assert records[0]['record_type'] == 'MS'
assert records[0]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[0]['value'] == 10.0
assert records[1]['sport_id'] == sport_1_cycling.id
assert records[1]['workout_id'] == workout_short_id
assert records[1]['record_type'] == 'LD'
assert records[1]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[1]['value'] == '1:00:00'
assert records[2]['sport_id'] == sport_1_cycling.id
assert records[2]['workout_id'] == workout_short_id
assert records[2]['record_type'] == 'FD'
assert records[2]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[2]['value'] == 10.0
assert records[3]['sport_id'] == sport_1_cycling.id
assert records[3]['workout_id'] == workout_short_id
assert records[3]['record_type'] == 'AS'
assert records[3]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[3]['value'] == 10.0
def test_returns_403_when_editing_an_workout_wo_gpx_from_different_user(
self,
app: Flask,
user_1: User,
user_2: User,
sport_1_cycling: Sport,
workout_cycling_user_2: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_cycling_user_2.short_id}',
content_type='application/json',
data=json.dumps(
dict(
sport_id=2,
duration=3600,
workout_date='2018-05-15 15:05',
distance=8,
title='Workout test',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 403
assert 'error' in data['status']
assert 'You do not have permissions.' in data['message']
def test_it_updates_an_workout_wo_gpx_with_timezone(
self,
app: Flask,
user_1_paris: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
workout_cycling_user_1: Workout,
) -> None:
workout_short_id = workout_cycling_user_1.short_id
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(
dict(
sport_id=2,
duration=3600,
workout_date='2018-05-15 15:05',
distance=8,
title='Workout test',
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert 'creation_date' in data['data']['workouts'][0]
assert (
data['data']['workouts'][0]['workout_date']
== 'Tue, 15 May 2018 13:05:00 GMT'
)
assert data['data']['workouts'][0]['user'] == 'test'
assert data['data']['workouts'][0]['sport_id'] == sport_2_running.id
assert data['data']['workouts'][0]['duration'] == '1:00:00'
assert data['data']['workouts'][0]['title'] == 'Workout test'
assert data['data']['workouts'][0]['ascent'] is None
assert data['data']['workouts'][0]['ave_speed'] == 8.0
assert data['data']['workouts'][0]['descent'] is None
assert data['data']['workouts'][0]['distance'] == 8.0
assert data['data']['workouts'][0]['max_alt'] is None
assert data['data']['workouts'][0]['max_speed'] == 8.0
assert data['data']['workouts'][0]['min_alt'] is None
assert data['data']['workouts'][0]['moving'] == '1:00:00'
assert data['data']['workouts'][0]['pauses'] is None
assert data['data']['workouts'][0]['with_gpx'] is False
records = data['data']['workouts'][0]['records']
assert len(records) == 4
assert records[0]['sport_id'] == sport_2_running.id
assert records[0]['workout_id'] == workout_short_id
assert records[0]['record_type'] == 'MS'
assert records[0]['workout_date'] == 'Tue, 15 May 2018 13:05:00 GMT'
assert records[0]['value'] == 8.0
assert records[1]['sport_id'] == sport_2_running.id
assert records[1]['workout_id'] == workout_short_id
assert records[1]['record_type'] == 'LD'
assert records[1]['workout_date'] == 'Tue, 15 May 2018 13:05:00 GMT'
assert records[1]['value'] == '1:00:00'
assert records[2]['sport_id'] == sport_2_running.id
assert records[2]['workout_id'] == workout_short_id
assert records[2]['record_type'] == 'FD'
assert records[2]['workout_date'] == 'Tue, 15 May 2018 13:05:00 GMT'
assert records[2]['value'] == 8.0
assert records[3]['sport_id'] == sport_2_running.id
assert records[3]['workout_id'] == workout_short_id
assert records[3]['record_type'] == 'AS'
assert records[3]['workout_date'] == 'Tue, 15 May 2018 13:05:00 GMT'
assert records[3]['value'] == 8.0
def test_it_updates_only_sport_and_distance_an_workout_wo_gpx(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
workout_cycling_user_1: Workout,
) -> None:
workout_short_id = workout_cycling_user_1.short_id
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(sport_id=2, distance=20)),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert 'creation_date' in data['data']['workouts'][0]
assert (
data['data']['workouts'][0]['workout_date']
== 'Mon, 01 Jan 2018 00:00:00 GMT'
)
assert data['data']['workouts'][0]['user'] == 'test'
assert data['data']['workouts'][0]['sport_id'] == sport_2_running.id
assert data['data']['workouts'][0]['duration'] == '1:00:00'
assert data['data']['workouts'][0]['title'] is None
assert data['data']['workouts'][0]['ascent'] is None
assert data['data']['workouts'][0]['ave_speed'] == 20.0
assert data['data']['workouts'][0]['descent'] is None
assert data['data']['workouts'][0]['distance'] == 20.0
assert data['data']['workouts'][0]['max_alt'] is None
assert data['data']['workouts'][0]['max_speed'] == 20.0
assert data['data']['workouts'][0]['min_alt'] is None
assert data['data']['workouts'][0]['moving'] == '1:00:00'
assert data['data']['workouts'][0]['pauses'] is None
assert data['data']['workouts'][0]['with_gpx'] is False
records = data['data']['workouts'][0]['records']
assert len(records) == 4
assert records[0]['sport_id'] == sport_2_running.id
assert records[0]['workout_id'] == workout_short_id
assert records[0]['record_type'] == 'MS'
assert records[0]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[0]['value'] == 20.0
assert records[1]['sport_id'] == sport_2_running.id
assert records[1]['workout_id'] == workout_short_id
assert records[1]['record_type'] == 'LD'
assert records[1]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[1]['value'] == '1:00:00'
assert records[2]['sport_id'] == sport_2_running.id
assert records[2]['workout_id'] == workout_short_id
assert records[2]['record_type'] == 'FD'
assert records[2]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[2]['value'] == 20.0
assert records[3]['sport_id'] == sport_2_running.id
assert records[3]['workout_id'] == workout_short_id
assert records[3]['record_type'] == 'AS'
assert records[3]['workout_date'] == 'Mon, 01 Jan 2018 00:00:00 GMT'
assert records[3]['value'] == 20.0
def test_it_returns_400_if_payload_is_empty(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_cycling_user_1.short_id}',
content_type='application/json',
data=json.dumps(dict()),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 400
assert 'error' in data['status']
assert 'Invalid payload.' in data['message']
def test_it_returns_500_if_date_format_is_invalid(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{workout_cycling_user_1.short_id}',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3600,
workout_date='15/2018',
distance=10,
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 500
assert 'error' in data['status']
assert (
'Error. Please try again or contact the administrator.'
in data['message']
)
def test_it_returns_404_if_edited_workout_does_not_exists(
self, app: Flask, user_1: User, sport_1_cycling: Sport
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.patch(
f'/api/workouts/{get_random_short_id()}',
content_type='application/json',
data=json.dumps(
dict(
sport_id=1,
duration=3600,
workout_date='2018-05-15 14:05',
distance=10,
)
),
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 404
assert 'not found' in data['status']
assert len(data['data']['workouts']) == 0
class TestRefreshWorkoutWithGpx:
def test_refresh_an_workout_with_gpx(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
sport_2_running: Sport,
gpx_file: str,
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
workout_uuid = decode_short_id(workout_short_id)
client = app.test_client()
# Edit some workout data
workout = Workout.query.filter_by(uuid=workout_uuid).first()
workout.ascent = 1000
workout.min_alt = -100
response = client.patch(
f'/api/workouts/{workout_short_id}',
content_type='application/json',
data=json.dumps(dict(refresh=True)),
headers=dict(Authorization=f'Bearer {token}'),
)
data = json.loads(response.data.decode())
assert response.status_code == 200
assert 'success' in data['status']
assert len(data['data']['workouts']) == 1
assert 1 == data['data']['workouts'][0]['sport_id']
assert 0.4 == data['data']['workouts'][0]['ascent']
assert 975.0 == data['data']['workouts'][0]['min_alt']

154
fittrackee/tests/workouts/test_workouts_api_3_delete.py Normal file
View File

@ -0,0 +1,154 @@
import json
import os
from fittrackee.users.models import User
from fittrackee.workouts.models import Sport, Workout
from fittrackee.workouts.utils import get_absolute_file_path
from flask import Flask
from .utils import get_random_short_id, post_an_workout
def get_gpx_filepath(workout_id: int) -> str:
workout = Workout.query.filter_by(id=workout_id).first()
return workout.gpx
class TestDeleteWorkoutWithGpx:
def test_it_deletes_an_workout_with_gpx(
self, app: Flask, user_1: User, sport_1_cycling: Sport, gpx_file: str
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
response = client.delete(
f'/api/workouts/{workout_short_id}',
headers=dict(Authorization=f'Bearer {token}'),
)
assert response.status_code == 204
def test_it_returns_403_when_deleting_an_workout_from_different_user(
self,
app: Flask,
user_1: User,
user_2: User,
sport_1_cycling: Sport,
gpx_file: str,
) -> None:
_, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='toto@toto.com', password='87654321')),
content_type='application/json',
)
response = client.delete(
f'/api/workouts/{workout_short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 403
assert 'error' in data['status']
assert 'You do not have permissions.' in data['message']
def test_it_returns_404_if_workout_does_not_exist(
self, app: Flask, user_1: User
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.delete(
f'/api/workouts/{get_random_short_id()}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 404
assert 'not found' in data['status']
def test_it_returns_500_when_deleting_an_workout_with_gpx_invalid_file(
self, app: Flask, user_1: User, sport_1_cycling: Sport, gpx_file: str
) -> None:
token, workout_short_id = post_an_workout(app, gpx_file)
client = app.test_client()
gpx_filepath = get_gpx_filepath(1)
gpx_filepath = get_absolute_file_path(gpx_filepath)
os.remove(gpx_filepath)
response = client.delete(
f'/api/workouts/{workout_short_id}',
headers=dict(Authorization=f'Bearer {token}'),
)
data = json.loads(response.data.decode())
assert response.status_code == 500
assert 'error' in data['status']
assert (
'Error. Please try again or contact the administrator.'
in data['message']
)
class TestDeleteWorkoutWithoutGpx:
def test_it_deletes_an_workout_wo_gpx(
self,
app: Flask,
user_1: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
response = client.delete(
f'/api/workouts/{workout_cycling_user_1.short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
assert response.status_code == 204
def test_it_returns_403_when_deleting_an_workout_from_different_user(
self,
app: Flask,
user_1: User,
user_2: User,
sport_1_cycling: Sport,
workout_cycling_user_1: Workout,
) -> None:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='toto@toto.com', password='87654321')),
content_type='application/json',
)
response = client.delete(
f'/api/workouts/{workout_cycling_user_1.short_id}',
headers=dict(
Authorization='Bearer '
+ json.loads(resp_login.data.decode())['auth_token']
),
)
data = json.loads(response.data.decode())
assert response.status_code == 403
assert 'error' in data['status']
assert 'You do not have permissions.' in data['message']

73
fittrackee/tests/workouts/test_workouts_model.py Normal file
View File

@ -0,0 +1,73 @@
from uuid import UUID
from fittrackee.users.models import User
from fittrackee.workouts.models import Sport, Workout
from fittrackee.workouts.utils_id import decode_short_id
from flask import Flask
class TestWorkoutModel:
def test_workout_model(
self,
app: Flask,
sport_1_cycling: Sport,
user_1: User,
workout_cycling_user_1: Workout,
) -> None:
workout_cycling_user_1.title = 'Test'
assert 1 == workout_cycling_user_1.id
assert workout_cycling_user_1.uuid is not None
assert 1 == workout_cycling_user_1.user_id
assert 1 == workout_cycling_user_1.sport_id
assert '2018-01-01 00:00:00' == str(
workout_cycling_user_1.workout_date
)
assert 10.0 == float(workout_cycling_user_1.distance)
assert '1:00:00' == str(workout_cycling_user_1.duration)
assert 'Test' == workout_cycling_user_1.title
assert '<Workout \'Cycling\' - 2018-01-01 00:00:00>' == str(
workout_cycling_user_1
)
serialized_workout = workout_cycling_user_1.serialize()
assert isinstance(decode_short_id(serialized_workout['id']), UUID)
assert 'test' == serialized_workout['user']
assert 1 == serialized_workout['sport_id']
assert serialized_workout['title'] == 'Test'
assert 'creation_date' in serialized_workout
assert serialized_workout['modification_date'] is not None
assert str(serialized_workout['workout_date']) == '2018-01-01 00:00:00'
assert serialized_workout['duration'] == '1:00:00'
assert serialized_workout['pauses'] is None
assert serialized_workout['moving'] == '1:00:00'
assert serialized_workout['distance'] == 10.0
assert serialized_workout['max_alt'] is None
assert serialized_workout['descent'] is None
assert serialized_workout['ascent'] is None
assert serialized_workout['max_speed'] == 10.0
assert serialized_workout['ave_speed'] == 10.0
assert serialized_workout['with_gpx'] is False
assert serialized_workout['bounds'] == []
assert serialized_workout['previous_workout'] is None
assert serialized_workout['next_workout'] is None
assert serialized_workout['segments'] == []
assert serialized_workout['records'] != []
assert serialized_workout['map'] is None
assert serialized_workout['weather_start'] is None
assert serialized_workout['weather_end'] is None
assert serialized_workout['notes'] is None
def test_workout_segment_model(
self,
app: Flask,
sport_1_cycling: Sport,
user_1: User,
workout_cycling_user_1: Workout,
workout_cycling_user_1_segment: Workout,
) -> None:
assert (
f'<Segment \'{workout_cycling_user_1_segment.segment_id}\' '
f'for workout \'{workout_cycling_user_1.short_id}\'>'
== str(workout_cycling_user_1_segment)
)

33
fittrackee/tests/workouts/utils.py Normal file
View File

@ -0,0 +1,33 @@
import json
from io import BytesIO
from typing import Tuple
from uuid import uuid4
from fittrackee.workouts.utils_id import encode_uuid
from flask import Flask
def get_random_short_id() -> str:
return encode_uuid(uuid4())
def post_an_workout(app: Flask, gpx_file: str) -> Tuple[str, str]:
client = app.test_client()
resp_login = client.post(
'/api/auth/login',
data=json.dumps(dict(email='test@test.com', password='12345678')),
content_type='application/json',
)
token = json.loads(resp_login.data.decode())['auth_token']
response = client.post(
'/api/workouts',
data=dict(
file=(BytesIO(str.encode(gpx_file)), 'example.gpx'),
data='{"sport_id": 1}',
),
headers=dict(
content_type='multipart/form-data', Authorization=f'Bearer {token}'
),
)
data = json.loads(response.data.decode())
return token, data['data']['workouts'][0]['id']