Changeset 24596da in OpenWorkouts-current for ow

Timestamp:

Feb 27, 2019, 6:28:07 PM (5 years ago)

Author:

Borja Lopez <borja@…>

Branches:

current, feature/docs, master

Children:

cef474f

Parents:

68d00f5

Message:

Added missing tests, raised overall coverage

Location:

ow

Files:

• tests/models/test_root.py (modified) (1 diff)
• tests/models/test_user.py (modified) (1 diff)
• tests/views/test_user.py (modified) (4 diffs)
• utilities.py (modified) (1 diff)
• views/user.py (modified) (1 diff)

ow/tests/models/test_root.py

@@ -112 +112 @@
             user = root.get_user_by_email(Mock())
 
+    def test_get_user_by_nickname(self, root, john):
+        # set a nickname for john
+        john.nickname = 'JohnDoe'
+        root.reindex(john)
+        user = root.get_user_by_nickname('JohnDoe')
+        assert user == john
+        user = root.get_user_by_nickname('NonExistant')
+        assert user is None
+        # passing in None
+        user = root.get_user_by_nickname(None)
+        assert user is None
+        # passing in something that is not None or a string will break
+        # the query code
+        with pytest.raises(TypeError):
+            user = root.get_user_by_nickname(False)
+        with pytest.raises(TypeError):
+            user = root.get_user_by_nickname(Mock())
+
     def test_users(self, root, john):
         assert root.users == [john]

ow/tests/models/test_user.py

@@ -348 +348 @@
             'time': timedelta(0)
         }
+
+    def test_yearly_stats(self, root):
+        expected_no_stats_per_month = {
+            'workouts': 0,
+            'time': timedelta(0),
+            'distance': Decimal(0),
+            'elevation': Decimal(0),
+            'sports': {}
+        }
+
+        yearly_stats = root['john'].yearly_stats
+        for month, stats in yearly_stats.items():
+            assert stats == expected_no_stats_per_month
+
+        # add a cycling workout
+        start_date = datetime.now(timezone.utc)
+        workout = Workout(
+            start=start_date,
+            duration=timedelta(minutes=(60*4)),
+            uphill=1200,
+            distance=115,
+            sport='cycling')
+        root['john'].add_workout(workout)
+
+        yearly_stats = root['john'].yearly_stats
+        for month, stats in yearly_stats.items():
+            if month == (start_date.year, start_date.month):
+                assert stats == {
+                    'workouts': 1,
+                    'time': timedelta(minutes=(60*4)),
+                    'distance': Decimal(115),
+                    'elevation': Decimal(1200),
+                    'sports': {
+                        'cycling': {'distance': Decimal(115),
+                                    'elevation': Decimal(1200),
+                                    'time': timedelta(minutes=(60*4)),
+                                    'workouts': 1}
+                    }
+                }
+            else:
+                assert stats == expected_no_stats_per_month
+
+        # add a second cycling workout
+        workout = Workout(
+            start=start_date,
+            duration=timedelta(minutes=(30)),
+            uphill=500,
+            distance=20,
+            sport='cycling')
+        root['john'].add_workout(workout)
+
+        yearly_stats = root['john'].yearly_stats
+        for month, stats in yearly_stats.items():
+            if month == (start_date.year, start_date.month):
+                assert stats == {
+                    'workouts': 2,
+                    'time': timedelta(minutes=((60*4)+30)),
+                    'distance': Decimal(115+20),
+                    'elevation': Decimal(1200+500),
+                    'sports': {
+                        'cycling': {'distance': Decimal(115+20),
+                                    'elevation': Decimal(1200+500),
+                                    'time': timedelta(minutes=((60*4)+30)),
+                                    'workouts': 2}
+                    }
+                }
+            else:
+                assert stats == expected_no_stats_per_month
+
+        # add a running workout
+        workout = Workout(
+            start=start_date,
+            duration=timedelta(minutes=(60)),
+            uphill=200,
+            distance=5,
+            sport='running')
+        root['john'].add_workout(workout)
+
+        yearly_stats = root['john'].yearly_stats
+        for month, stats in yearly_stats.items():
+            if month == (start_date.year, start_date.month):
+                assert stats == {
+                    'workouts': 3,
+                    'time': timedelta(minutes=((60*4)+30+60)),
+                    'distance': Decimal(115+20+5),
+                    'elevation': Decimal(1200+500+200),
+                    'sports': {
+                        'cycling': {'distance': Decimal(115+20),
+                                    'elevation': Decimal(1200+500),
+                                    'time': timedelta(minutes=((60*4)+30)),
+                                    'workouts': 2},
+                        'running': {'distance': Decimal(5),
+                                    'elevation': Decimal(200),
+                                    'time': timedelta(minutes=(60)),
+                                    'workouts': 1}
+                    }
+                }
+            else:
+                assert stats == expected_no_stats_per_month
+
+    def test_weekly_year_stats(self, root):
+        expected_no_stats_per_week = {
+            'workouts': 0,
+            'time': timedelta(0),
+            'distance': Decimal(0),
+            'elevation': Decimal(0),
+            'sports': {}
+        }
+
+        weekly_year_stats = root['john'].weekly_year_stats
+        for week, stats in weekly_year_stats.items():
+            assert stats == expected_no_stats_per_week
+
+        # add a cycling workout
+        start_date = datetime.now(timezone.utc)
+        workout = Workout(
+            start=start_date,
+            duration=timedelta(minutes=(60*4)),
+            uphill=1200,
+            distance=115,
+            sport='cycling')
+        root['john'].add_workout(workout)
+
+        weekly_year_stats = root['john'].weekly_year_stats
+        workout_week = (start_date.year, start_date.month,
+                        start_date.isocalendar()[1])
+        for week, stats in weekly_year_stats.items():
+            if week[:3] == workout_week:
+                assert stats == {
+                    'workouts': 1,
+                    'time': timedelta(minutes=(60*4)),
+                    'distance': Decimal(115),
+                    'elevation': Decimal(1200),
+                    'sports': {
+                        'cycling': {'distance': Decimal(115),
+                                    'elevation': Decimal(1200),
+                                    'time': timedelta(minutes=(60*4)),
+                                    'workouts': 1}
+                    }
+                }
+            else:
+                assert stats == expected_no_stats_per_week
+
+        # add a second cycling workout
+        workout = Workout(
+            start=start_date,
+            duration=timedelta(minutes=(30)),
+            uphill=500,
+            distance=20,
+            sport='cycling')
+        root['john'].add_workout(workout)
+
+        weekly_year_stats = root['john'].weekly_year_stats
+        workout_week = (start_date.year, start_date.month,
+                        start_date.isocalendar()[1])
+        for week, stats in weekly_year_stats.items():
+            if week[:3] == workout_week:
+                assert stats == {
+                    'workouts': 2,
+                    'time': timedelta(minutes=((60*4)+30)),
+                    'distance': Decimal(115+20),
+                    'elevation': Decimal(1200+500),
+                    'sports': {
+                        'cycling': {'distance': Decimal(115+20),
+                                    'elevation': Decimal(1200+500),
+                                    'time': timedelta(minutes=((60*4)+30)),
+                                    'workouts': 2}
+                    }
+                }
+            else:
+                assert stats == expected_no_stats_per_week
+
+        # add a running workout
+        workout = Workout(
+            start=start_date,
+            duration=timedelta(minutes=(60)),
+            uphill=200,
+            distance=5,
+            sport='running')
+        root['john'].add_workout(workout)
+
+        weekly_year_stats = root['john'].weekly_year_stats
+        workout_week = (start_date.year, start_date.month,
+                        start_date.isocalendar()[1])
+        for week, stats in weekly_year_stats.items():
+            if week[:3] == workout_week:
+                assert stats == {
+                    'workouts': 3,
+                    'time': timedelta(minutes=((60*4)+30+60)),
+                    'distance': Decimal(115+20+5),
+                    'elevation': Decimal(1200+500+200),
+                    'sports': {
+                        'cycling': {'distance': Decimal(115+20),
+                                    'elevation': Decimal(1200+500),
+                                    'time': timedelta(minutes=((60*4)+30)),
+                                    'workouts': 2},
+                        'running': {'distance': Decimal(5),
+                                    'elevation': Decimal(200),
+                                    'time': timedelta(minutes=(60)),
+                                    'workouts': 1}
+                    }
+                }
+            else:
+                assert stats == expected_no_stats_per_week

ow/tests/views/test_user.py

@@ -13 +13 @@
 
 from pyramid.testing import DummyRequest
-from pyramid.httpexceptions import HTTPFound
+from pyramid.httpexceptions import HTTPFound, HTTPNotFound
 from pyramid.response import Response
 
@@ -475 +475 @@
         }
 
+    def test_profile_with_nickname(self, dummy_request, john):
+        """
+        Loading the profile page using the user nickname
+        """
+        request = dummy_request
+        john.nickname = 'JohnDoe'
+        request.root.reindex(john)
+        # first load using the uuid
+        response_uuid = user_views.profile(john, request)
+        # now, do it with the nickname
+        request.subpath = ['JohnDoe']
+        response_nickname = user_views.profile(request.root, request)
+        assert response_uuid == response_nickname
+        # try an unknown nickname, HTTPNotFound is returned
+        request.subpath = ['Invalid']
+        response_nickname = user_views.profile(request.root, request)
+        assert isinstance(response_nickname, HTTPNotFound)
+
     def test_login_get(self, dummy_request):
         """
@@ -675 +693 @@
         returned_image = Image.open(BytesIO(response.body))
         assert original_image.size == returned_image.size
+
+    def test_profile_picture_none(self, dummy_request, john):
+        """
+        GET request for an user without a profile picture
+        """
+        request = dummy_request
+        user = john
+        response = user_views.profile_picture(user, request)
+        assert isinstance(response, HTTPNotFound)
 
     def test_edit_profile_get(self, dummy_request, john):
@@ -1002 +1029 @@
                 day['time'] == '00'
                 day['workouts'] == 0
+
+    def test_last_months_stats(self, dummy_request, john):
+        request = dummy_request
+        user = john
+        response = user_views.last_months_stats(user, request)
+        assert isinstance(response, Response)
+        assert response.content_type == 'application/json'
+        # the body is a valid json-encoded stream
+        obj = json.loads(response.body)
+        assert len(obj) == 13
+        for month in obj:
+            assert len(month.keys()) == 7
+            assert 'id' in month.keys()
+            assert 'name' in month.keys()
+            assert month['distance'] == 0
+            assert month['elevation'] == 0
+            assert month['time'] == '00'
+            assert month['workouts'] == 0
+            assert str(user.uid) in month['url']
+            assert 'profile' in month['url']
+            assert 'year' in month['url']
+            assert 'month' in month['url']
+
+        # try now with a workout
+        workout_start = datetime.now(timezone.utc)
+        workout_start_id = (
+            str(workout_start.year) + '-' + str(workout_start.month).zfill(2))
+        workout = Workout(
+            sport='cycling',
+            start=workout_start,
+            duration=timedelta(minutes=60),
+            distance=30,
+            uphill=540
+        )
+        user.add_workout(workout)
+        response = user_views.last_months_stats(user, request)
+        assert isinstance(response, Response)
+        assert response.content_type == 'application/json'
+        # the body is a valid json-encoded stream
+        obj = json.loads(response.body)
+        assert len(obj) == 13
+        for month in obj:
+            assert len(month.keys()) == 7
+            assert 'id' in month.keys()
+            assert 'name' in month.keys()
+            assert str(user.uid) in month['url']
+            assert 'profile' in month['url']
+            assert 'year' in month['url']
+            assert 'month' in month['url']
+            if month['id'] == workout_start_id:
+                assert month['distance'] == 30
+                assert month['elevation'] == 540
+                assert month['time'] == '01'
+                assert month['workouts'] == 1
+            else:
+                assert month['distance'] == 0
+                assert month['elevation'] == 0
+                assert month['time'] == '00'
+                assert month['workouts'] == 0
+
+    def test_last_weeks_stats(self, dummy_request, john):
+        request = dummy_request
+        user = john
+        response = user_views.last_weeks_stats(user, request)
+        assert isinstance(response, Response)
+        assert response.content_type == 'application/json'
+        # the body is a valid json-encoded stream
+        obj = json.loads(response.body)
+        assert len(obj) == 68
+        for week in obj:
+            assert len(week.keys()) == 8
+            assert 'id' in week.keys()
+            assert 'name' in week.keys()
+            assert 'week' in week.keys()
+            assert week['distance'] == 0
+            assert week['elevation'] == 0
+            assert week['time'] == '00'
+            assert week['workouts'] == 0
+            assert str(user.uid) in week['url']
+            assert 'profile' in week['url']
+            assert 'year' in week['url']
+            assert 'month' in week['url']
+            assert 'week' in week['url']
+
+        # try now with a workout
+        workout_start = datetime.now(timezone.utc)
+        workout_start_id = str(workout_start.year)
+        workout_start_id += '-' + str(workout_start.month).zfill(2)
+        workout_start_id += '-' + str(workout_start.isocalendar()[1])
+        workout = Workout(
+            sport='cycling',
+            start=workout_start,
+            duration=timedelta(minutes=60),
+            distance=30,
+            uphill=540
+        )
+        user.add_workout(workout)
+        response = user_views.last_weeks_stats(user, request)
+        assert isinstance(response, Response)
+        assert response.content_type == 'application/json'
+        # the body is a valid json-encoded stream
+        obj = json.loads(response.body)
+        assert len(obj) == 68
+        for week in obj:
+            assert len(week.keys()) == 8
+            assert 'id' in week.keys()
+            assert 'name' in week.keys()
+            assert 'week' in week.keys()
+            assert str(user.uid) in week['url']
+            assert 'profile' in week['url']
+            assert 'year' in week['url']
+            assert 'month' in week['url']
+            assert 'week' in week['url']
+            if week['id'] == workout_start_id:
+                assert week['distance'] == 30
+                assert week['elevation'] == 540
+                assert week['time'] == '01'
+                assert week['workouts'] == 1
+            else:
+                assert week['distance'] == 0
+                assert week['elevation'] == 0
+                assert week['time'] == '00'
+                assert week['workouts'] == 0

ow/utilities.py

@@ -279 +279 @@
         if day.day in week:
             return weeks.index(week)
-    return None
 
 

ow/views/user.py

@@ -302 +302 @@
     user_gender = _('Unknown')
     for g in get_gender_names():
-        if g[0] == context.gender:
+        if g[0] == user.gender:
             user_gender = localizer.translate(g[1])