From 7970a4023e295d1925913e6253142d332989f945 Mon Sep 17 00:00:00 2001
From: andrerim <andreasrim@gmail.com>
Date: Sun, 14 Mar 2021 11:00:46 +0100
Subject: [PATCH 1/9] Add integration tests

---
 backend/secfit/integrationtests/tests.py | 180 +++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 backend/secfit/integrationtests/tests.py

diff --git a/backend/secfit/integrationtests/tests.py b/backend/secfit/integrationtests/tests.py
new file mode 100644
index 0000000..61b4664
--- /dev/null
+++ b/backend/secfit/integrationtests/tests.py
@@ -0,0 +1,180 @@
+from django.test import Client, TestCase
+from rest_framework.test import APIClient
+from rest_framework.authtoken.models import Token
+from http.cookies import SimpleCookie
+from django.contrib.auth import get_user
+from rest_framework.test import force_authenticate
+from users.serializers import UserSerializer
+from users.models import User
+from workouts.serializers import ExerciseSerializer
+
+
+def create_user_data(**kwargs):
+    data = {
+        "username": "",
+        "email": "",
+        "password": "",
+        "password1": "",
+        "phone_number": "",
+        "country": "",
+        "city": "",
+        "street_address": "",
+    }
+    for key, val in kwargs.items():
+        if key in data:
+            data[key] = val
+    return data
+
+
+def create_exercise_data(**kwargs):
+    data = {
+        "name": "",
+        "description": "",
+        "unit": "",
+    }
+    for key, val in kwargs.items():
+        if key in data:
+            data[key] = val
+    return data
+
+
+class TestFiltering(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        self.user_serializer = UserSerializer()
+        self.valid_data = create_user_data(
+            username="tyrion",
+            email="tyrion@lannister.com",
+            password="iDrInKaNdIkNoWtHiNgS",
+            password1="iDrInKaNdIkNoWtHiNgS",
+            phone_number="+4791827364",
+            country="Crownlands",
+            city="King's Landing",
+            street_address="The Red Keep 404",
+        )
+
+        data = self.user_serializer.validate(self.valid_data)
+        self.assertEqual(data, self.valid_data)
+        user = self.user_serializer.create(data)
+        self.assertIsNotNone(user.password)
+        self.assertFalse(hasattr(user, "password1"))
+        for attr, value in data.items():
+            if attr not in ["password", "password1"]:
+                self.assertEqual(getattr(user, attr), data[attr])
+
+        self.exerciseSerializer = ExerciseSerializer()
+        self.valid_data = create_exercise_data(
+            name="Squats",
+            description="Bend knees",
+            unit="kg"
+        )
+        data = self.exerciseSerializer.validate(self.valid_data)
+        self.exerciseSerializer.create(data)
+
+    # get exercise types for filtering FR X
+    def test_get_exercise_types(self):
+        user = User.objects.get(username='tyrion')
+        self.client.force_authenticate(user=user)
+        response = self.client.get('/api/exercises/')
+
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertGreater(len(data['results']), 0)
+
+    def test_get_workouts(self):
+        user = User.objects.get(username='tyrion')
+        self.client.force_authenticate(user=user)
+        response = self.client.get('/api/workouts/')
+        self.assertEqual(response.status_code, 200)
+        print(response.json())
+
+
+class TestHighScore(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        self.user_serializer = UserSerializer()
+        self.valid_data = create_user_data(
+            username="tyrion",
+            email="tyrion@lannister.com",
+            password="iDrInKaNdIkNoWtHiNgS",
+            password1="iDrInKaNdIkNoWtHiNgS",
+            phone_number="+4791827364",
+            country="Crownlands",
+            city="King's Landing",
+            street_address="The Red Keep 404",
+        )
+
+        data = self.user_serializer.validate(self.valid_data)
+        self.assertEqual(data, self.valid_data)
+        user = self.user_serializer.create(data)
+        self.assertIsNotNone(user.password)
+        self.assertFalse(hasattr(user, "password1"))
+        for attr, value in data.items():
+            if attr not in ["password", "password1"]:
+                self.assertEqual(getattr(user, attr), data[attr])
+
+        self.exerciseSerializer = ExerciseSerializer()
+        self.valid_data = create_exercise_data(
+            name="Squats",
+            description="Bend knees",
+            unit="kg"
+        )
+        data = self.exerciseSerializer.validate(self.valid_data)
+        self.exerciseSerializer.create(data)
+
+    def test_get_highscore(self):
+        user = User.objects.get(username='tyrion')
+        self.client.force_authenticate(user=user)
+        response = self.client.get('/api/highscores/')
+
+        print(response.json())
+        self.assertEqual(response.status_code, 200)
+
+    def test_get_highscore_for_exercise(self):
+        user = User.objects.get(username='tyrion')
+        self.client.force_authenticate(user=user)
+        response = self.client.get('/api/highscores/?exercise=1')
+        self.assertEqual(response.status_code, 200)
+
+
+class TestProfile(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        self.user_serializer = UserSerializer()
+        self.valid_data = create_user_data(
+            username="tyrion",
+            email="tyrion@lannister.com",
+            password="iDrInKaNdIkNoWtHiNgS",
+            password1="iDrInKaNdIkNoWtHiNgS",
+            phone_number="+4791827364",
+            country="Crownlands",
+            city="King's Landing",
+            street_address="The Red Keep 404",
+        )
+
+        data = self.user_serializer.validate(self.valid_data)
+        self.assertEqual(data, self.valid_data)
+        user = self.user_serializer.create(data)
+        self.assertIsNotNone(user.password)
+        self.assertFalse(hasattr(user, "password1"))
+        for attr, value in data.items():
+            if attr not in ["password", "password1"]:
+                self.assertEqual(getattr(user, attr), data[attr])
+
+        self.exerciseSerializer = ExerciseSerializer()
+        self.valid_data = create_exercise_data(
+            name="Squats",
+            description="Bend knees",
+            unit="kg"
+        )
+        data = self.exerciseSerializer.validate(self.valid_data)
+        self.exerciseSerializer.create(data)
+
+    def test_get_highscore(self):
+        user = User.objects.get(username='tyrion')
+        self.client.force_authenticate(user=user)
+        response = self.client.get('/api/highscores/')
+
+        print(response.json())
+        self.assertEqual(response.status_code, 200)
+   
\ No newline at end of file
-- 
GitLab


From d88c5a380d0980b7eafef26ca1cc37d50989d4cc Mon Sep 17 00:00:00 2001
From: Andreas <andrerim@stud.ntnu.no>
Date: Sun, 14 Mar 2021 14:49:28 +0100
Subject: [PATCH 2/9] Add integration test for filter, highscore and profile

---
 backend/secfit/integrationtests/tests.py | 210 ++++++++++++-----------
 1 file changed, 111 insertions(+), 99 deletions(-)

diff --git a/backend/secfit/integrationtests/tests.py b/backend/secfit/integrationtests/tests.py
index 61b4664..2e5bfbc 100644
--- a/backend/secfit/integrationtests/tests.py
+++ b/backend/secfit/integrationtests/tests.py
@@ -6,7 +6,9 @@ from django.contrib.auth import get_user
 from rest_framework.test import force_authenticate
 from users.serializers import UserSerializer
 from users.models import User
-from workouts.serializers import ExerciseSerializer
+from workouts.serializers import ExerciseSerializer, WorkoutSerializer
+from django.utils import timezone
+from workouts.models import Exercise
 
 
 def create_user_data(**kwargs):
@@ -38,101 +40,130 @@ def create_exercise_data(**kwargs):
     return data
 
 
+def create_workout_data(**kwargs):
+    data = {
+        "owner": "",
+        "name": "",
+        "date": timezone.now(),
+        "notes": "",
+        "visibility": "",
+        "exercise_instances": ""
+    }
+    for key, val in kwargs.items():
+        if key in data:
+            data[key] = val
+    return data
+
+
 class TestFiltering(TestCase):
-    def setUp(self):
-        self.client = APIClient()
-        self.user_serializer = UserSerializer()
-        self.valid_data = create_user_data(
-            username="tyrion",
+
+    @staticmethod
+    def create_user(username='tyrion'):
+        user_serializer = UserSerializer()
+        valid_data = create_user_data(
+            username=username,
             email="tyrion@lannister.com",
             password="iDrInKaNdIkNoWtHiNgS",
             password1="iDrInKaNdIkNoWtHiNgS",
-            phone_number="+4791827364",
-            country="Crownlands",
-            city="King's Landing",
-            street_address="The Red Keep 404",
         )
+        user_serializer.create(valid_data)
+
+    @staticmethod
+    def create_exercises(amount):
+        exerciseSerializer = ExerciseSerializer()
+        for i in range(amount):
+            valid_data = create_exercise_data(
+                name="Squats" + str(i),
+                description="Bend knees" + str(i),
+                unit="kg"
+            )
+            exerciseSerializer.create(valid_data)
+
+    @staticmethod
+    def create_workouts(user, amount):
+        workoutSerializer = WorkoutSerializer()
+        test = Exercise.objects.get(id="1")
+        for i in range(amount):
+            valid_data = create_workout_data(
+                owner=user,
+                name="Super big hard workout" + str(i),
+                notes="It was easy" + str(i),
+                visibility="PU",
+                exercise_instances=[{
+                    "exercise": test,
+                    "sets": 123,
+                    "number": 321
+                }]
+            )
+            workoutSerializer.create(valid_data)
 
-        data = self.user_serializer.validate(self.valid_data)
-        self.assertEqual(data, self.valid_data)
-        user = self.user_serializer.create(data)
-        self.assertIsNotNone(user.password)
-        self.assertFalse(hasattr(user, "password1"))
-        for attr, value in data.items():
-            if attr not in ["password", "password1"]:
-                self.assertEqual(getattr(user, attr), data[attr])
-
-        self.exerciseSerializer = ExerciseSerializer()
-        self.valid_data = create_exercise_data(
-            name="Squats",
-            description="Bend knees",
-            unit="kg"
-        )
-        data = self.exerciseSerializer.validate(self.valid_data)
-        self.exerciseSerializer.create(data)
+    def setUp(self):
+        self.client = APIClient()
+
+        self.create_user()
+
+        # create >10 exercise types for pagination testing
+        self.exercise_count = 15
+        self.create_exercises(self.exercise_count)
+
+        self.user = User.objects.get(username='tyrion')
+        self.create_workouts(self.user, 1)
 
     # get exercise types for filtering FR X
     def test_get_exercise_types(self):
-        user = User.objects.get(username='tyrion')
-        self.client.force_authenticate(user=user)
+        self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/exercises/')
 
         self.assertEqual(response.status_code, 200)
         data = response.json()
+
+        self.assertEqual(data['count'], self.exercise_count)
         self.assertGreater(len(data['results']), 0)
 
+    def test_exercise_types_pagination(self):
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get('/api/exercises/')
+
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results_count = len(data['results'])
+        response = self.client.get(data['next'])
+
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results_count += len(data['results'])
+
+        self.assertEqual(results_count, self.exercise_count)
+
     def test_get_workouts(self):
-        user = User.objects.get(username='tyrion')
-        self.client.force_authenticate(user=user)
+        self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/workouts/')
         self.assertEqual(response.status_code, 200)
-        print(response.json())
 
 
 class TestHighScore(TestCase):
     def setUp(self):
         self.client = APIClient()
-        self.user_serializer = UserSerializer()
-        self.valid_data = create_user_data(
-            username="tyrion",
-            email="tyrion@lannister.com",
-            password="iDrInKaNdIkNoWtHiNgS",
-            password1="iDrInKaNdIkNoWtHiNgS",
-            phone_number="+4791827364",
-            country="Crownlands",
-            city="King's Landing",
-            street_address="The Red Keep 404",
-        )
 
-        data = self.user_serializer.validate(self.valid_data)
-        self.assertEqual(data, self.valid_data)
-        user = self.user_serializer.create(data)
-        self.assertIsNotNone(user.password)
-        self.assertFalse(hasattr(user, "password1"))
-        for attr, value in data.items():
-            if attr not in ["password", "password1"]:
-                self.assertEqual(getattr(user, attr), data[attr])
-
-        self.exerciseSerializer = ExerciseSerializer()
-        self.valid_data = create_exercise_data(
-            name="Squats",
-            description="Bend knees",
-            unit="kg"
-        )
-        data = self.exerciseSerializer.validate(self.valid_data)
-        self.exerciseSerializer.create(data)
+        TestFiltering.create_user()
+
+        # create >10 exercise types for pagination testing
+        self.exercise_count = 15
+        TestFiltering.create_exercises(self.exercise_count)
+
+        self.user = User.objects.get(username='tyrion')
+        TestFiltering.create_workouts(self.user, 1)
 
     def test_get_highscore(self):
-        user = User.objects.get(username='tyrion')
-        self.client.force_authenticate(user=user)
+        self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/highscores/')
 
-        print(response.json())
         self.assertEqual(response.status_code, 200)
 
     def test_get_highscore_for_exercise(self):
-        user = User.objects.get(username='tyrion')
-        self.client.force_authenticate(user=user)
+        self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/highscores/?exercise=1')
         self.assertEqual(response.status_code, 200)
 
@@ -140,41 +171,22 @@ class TestHighScore(TestCase):
 class TestProfile(TestCase):
     def setUp(self):
         self.client = APIClient()
-        self.user_serializer = UserSerializer()
-        self.valid_data = create_user_data(
-            username="tyrion",
-            email="tyrion@lannister.com",
-            password="iDrInKaNdIkNoWtHiNgS",
-            password1="iDrInKaNdIkNoWtHiNgS",
-            phone_number="+4791827364",
-            country="Crownlands",
-            city="King's Landing",
-            street_address="The Red Keep 404",
-        )
 
-        data = self.user_serializer.validate(self.valid_data)
-        self.assertEqual(data, self.valid_data)
-        user = self.user_serializer.create(data)
-        self.assertIsNotNone(user.password)
-        self.assertFalse(hasattr(user, "password1"))
-        for attr, value in data.items():
-            if attr not in ["password", "password1"]:
-                self.assertEqual(getattr(user, attr), data[attr])
-
-        self.exerciseSerializer = ExerciseSerializer()
-        self.valid_data = create_exercise_data(
-            name="Squats",
-            description="Bend knees",
-            unit="kg"
-        )
-        data = self.exerciseSerializer.validate(self.valid_data)
-        self.exerciseSerializer.create(data)
+        TestFiltering.create_user()
+        TestFiltering.create_user(username='arya')
+        self.user = User.objects.get(username='tyrion')
 
-    def test_get_highscore(self):
-        user = User.objects.get(username='tyrion')
-        self.client.force_authenticate(user=user)
-        response = self.client.get('/api/highscores/')
+    def test_get_user_data(self):
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get('/api/users/?user=current')
 
-        print(response.json())
         self.assertEqual(response.status_code, 200)
-   
\ No newline at end of file
+
+        data = response.json()
+
+        self.assertEqual(data['count'], 1)
+
+        user_data = data['results'][0]
+
+        self.assertEqual(user_data['username'], 'tyrion')
+        self.assertEqual(user_data['email'], 'tyrion@lannister.com')
-- 
GitLab


From 0abfa9b21792b01bb218065c1460a3ede38b15d4 Mon Sep 17 00:00:00 2001
From: Andreas <andrerim@stud.ntnu.no>
Date: Sun, 14 Mar 2021 14:54:24 +0100
Subject: [PATCH 3/9] Add integration tests to pipeline

---
 backend/secfit/.gitlab-ci.yml | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/backend/secfit/.gitlab-ci.yml b/backend/secfit/.gitlab-ci.yml
index 7f5f578..a313a2a 100644
--- a/backend/secfit/.gitlab-ci.yml
+++ b/backend/secfit/.gitlab-ci.yml
@@ -15,3 +15,21 @@ test backend:
     - cd backend/secfit
     - coverage run --source='.' manage.py test
     - coverage report
+
+integration test: 
+  stage: test
+  image: python:3.8.6-slim
+  cache:
+    paths:
+    - ~/.cache/pip/
+
+  before_script:
+    - apt-get update -qy
+    - apt-get install -y libpq-dev python3-dev gcc
+    - pip install -r backend/secfit/requirements.txt
+    - pip install coverage
+
+  script:
+    - cd backend/secfit
+    - coverage run --source='.' manage.py test integrationtests/
+    - coverage report
-- 
GitLab


From 427b926f29f676025b88bf89f22514709167cf33 Mon Sep 17 00:00:00 2001
From: Andreas <andrerim@stud.ntnu.no>
Date: Sun, 14 Mar 2021 15:47:34 +0100
Subject: [PATCH 4/9] Fix integration tests to pipeline

---
 backend/secfit/.gitlab-ci.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/backend/secfit/.gitlab-ci.yml b/backend/secfit/.gitlab-ci.yml
index a313a2a..a66dd74 100644
--- a/backend/secfit/.gitlab-ci.yml
+++ b/backend/secfit/.gitlab-ci.yml
@@ -1,3 +1,7 @@
+stages:
+  - test backend
+  - integration test
+
 test backend:
   stage: test
   image: python:3.8.6-slim
-- 
GitLab


From 3f4ba2e5446ea12f50212c10d2dc6f0a8c9eb16c Mon Sep 17 00:00:00 2001
From: Andreas <andrerim@stud.ntnu.no>
Date: Sun, 14 Mar 2021 19:55:43 +0100
Subject: [PATCH 5/9] Improve tests

---
 backend/secfit/integrationtests/tests.py | 100 +++++++++++++++--------
 1 file changed, 66 insertions(+), 34 deletions(-)

diff --git a/backend/secfit/integrationtests/tests.py b/backend/secfit/integrationtests/tests.py
index 2e5bfbc..8a97aaf 100644
--- a/backend/secfit/integrationtests/tests.py
+++ b/backend/secfit/integrationtests/tests.py
@@ -1,14 +1,10 @@
-from django.test import Client, TestCase
-from rest_framework.test import APIClient
-from rest_framework.authtoken.models import Token
-from http.cookies import SimpleCookie
-from django.contrib.auth import get_user
-from rest_framework.test import force_authenticate
-from users.serializers import UserSerializer
-from users.models import User
-from workouts.serializers import ExerciseSerializer, WorkoutSerializer
+from django.test import TestCase
 from django.utils import timezone
+from rest_framework.test import APIClient, force_authenticate
+from users.models import User
+from users.serializers import UserSerializer
 from workouts.models import Exercise
+from workouts.serializers import ExerciseSerializer, WorkoutSerializer
 
 
 def create_user_data(**kwargs):
@@ -70,6 +66,7 @@ class TestFiltering(TestCase):
 
     @staticmethod
     def create_exercises(amount):
+        # create >10 exercise types for pagination testing
         exerciseSerializer = ExerciseSerializer()
         for i in range(amount):
             valid_data = create_exercise_data(
@@ -80,36 +77,33 @@ class TestFiltering(TestCase):
             exerciseSerializer.create(valid_data)
 
     @staticmethod
-    def create_workouts(user, amount):
+    def create_workout(user):
         workoutSerializer = WorkoutSerializer()
         test = Exercise.objects.get(id="1")
-        for i in range(amount):
-            valid_data = create_workout_data(
-                owner=user,
-                name="Super big hard workout" + str(i),
-                notes="It was easy" + str(i),
-                visibility="PU",
-                exercise_instances=[{
-                    "exercise": test,
-                    "sets": 123,
-                    "number": 321
-                }]
-            )
-            workoutSerializer.create(valid_data)
+        valid_data = create_workout_data(
+            owner=user,
+            name="Super big hard workout",
+            notes="It was easy",
+            visibility="PU",
+            exercise_instances=[{
+                "exercise": test,
+                "sets": 123,
+                "number": 123
+            }]
+        )
+        workoutSerializer.create(valid_data)
 
     def setUp(self):
         self.client = APIClient()
 
         self.create_user()
 
-        # create >10 exercise types for pagination testing
         self.exercise_count = 15
         self.create_exercises(self.exercise_count)
 
         self.user = User.objects.get(username='tyrion')
-        self.create_workouts(self.user, 1)
+        self.create_workout(self.user)
 
-    # get exercise types for filtering FR X
     def test_get_exercise_types(self):
         self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/exercises/')
@@ -147,26 +141,56 @@ class TestHighScore(TestCase):
     def setUp(self):
         self.client = APIClient()
 
-        TestFiltering.create_user()
-
-        # create >10 exercise types for pagination testing
         self.exercise_count = 15
         TestFiltering.create_exercises(self.exercise_count)
 
-        self.user = User.objects.get(username='tyrion')
-        TestFiltering.create_workouts(self.user, 1)
+        TestFiltering.create_user()
+        self.user1 = User.objects.get(username='tyrion')
+        self.user1_workout_instances = 5
+        for _ in range(self.user1_workout_instances):
+            TestFiltering.create_workout(self.user1)
 
-    def test_get_highscore(self):
-        self.client.force_authenticate(user=self.user)
+        TestFiltering.create_user(username='arya')
+        self.user2 = User.objects.get(username='arya')
+        self.user2_workout_instances = 1
+        for _ in range(self.user2_workout_instances):
+            TestFiltering.create_workout(self.user2)
+
+    def test_get_highscores(self):
+        self.client.force_authenticate(user=self.user1)
         response = self.client.get('/api/highscores/')
 
         self.assertEqual(response.status_code, 200)
 
+        data = response.json()
+        highscores = data['count']
+
+        self.assertEqual(highscores, 2)
+
+    def test_get_highscore_for_non_existing_exercise(self):
+        self.client.force_authenticate(user=self.user1)
+        response = self.client.get('/api/highscores/?exercise=2')
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results = len(data['results'])
+        self.assertEqual(results, 0)
+
     def test_get_highscore_for_exercise(self):
-        self.client.force_authenticate(user=self.user)
+        self.client.force_authenticate(user=self.user1)
         response = self.client.get('/api/highscores/?exercise=1')
         self.assertEqual(response.status_code, 200)
 
+        data = response.json()
+        results = data['results']
+        for res in results:
+            if res['username'] == 'tyrion':
+                self.assertEqual(res['score'],  self.user1_workout_instances)
+            elif res['username'] == 'arya':
+                self.assertEqual(res['score'],  self.user2_workout_instances)
+            else:
+                raise Exception("No user match")
+
 
 class TestProfile(TestCase):
     def setUp(self):
@@ -176,6 +200,14 @@ class TestProfile(TestCase):
         TestFiltering.create_user(username='arya')
         self.user = User.objects.get(username='tyrion')
 
+    def test_get_user_data_not_authenticated(self):
+        response = self.client.get('/api/users/?user=current')
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+
+        self.assertEqual(data['count'], 0)
+
     def test_get_user_data(self):
         self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/users/?user=current')
-- 
GitLab


From 0eed60e92d25aface899ac98802f9dfb1c8f3484 Mon Sep 17 00:00:00 2001
From: Andreas <andrerim@stud.ntnu.no>
Date: Sun, 14 Mar 2021 20:34:22 +0100
Subject: [PATCH 6/9] Refactor integrationtests

---
 backend/secfit/integrationtests/testfilter.py |  48 ++++
 .../secfit/integrationtests/testhighscore.py  |  59 +++++
 .../secfit/integrationtests/testprofile.py    |  36 +++
 backend/secfit/integrationtests/tests.py      | 224 ------------------
 backend/secfit/integrationtests/util.py       |  91 +++++++
 5 files changed, 234 insertions(+), 224 deletions(-)
 create mode 100644 backend/secfit/integrationtests/testfilter.py
 create mode 100644 backend/secfit/integrationtests/testhighscore.py
 create mode 100644 backend/secfit/integrationtests/testprofile.py
 delete mode 100644 backend/secfit/integrationtests/tests.py
 create mode 100644 backend/secfit/integrationtests/util.py

diff --git a/backend/secfit/integrationtests/testfilter.py b/backend/secfit/integrationtests/testfilter.py
new file mode 100644
index 0000000..ad5fb0d
--- /dev/null
+++ b/backend/secfit/integrationtests/testfilter.py
@@ -0,0 +1,48 @@
+from django.test import TestCase
+from rest_framework.test import APIClient, force_authenticate
+from users.models import User
+
+import util
+
+class TestFiltering(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+
+        self.exercise_count = 15
+        util.create_exercises(self.exercise_count)
+
+        util.create_user('tyrion')
+        self.user = User.objects.get(username='tyrion')
+        util.create_workout(self.user)
+
+    def test_get_exercise_types(self):
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get('/api/exercises/')
+
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+
+        self.assertEqual(data['count'], self.exercise_count)
+        self.assertGreater(len(data['results']), 0)
+
+    def test_exercise_types_pagination(self):
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get('/api/exercises/')
+
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results_count = len(data['results'])
+        response = self.client.get(data['next'])
+
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results_count += len(data['results'])
+
+        self.assertEqual(results_count, self.exercise_count)
+
+    def test_get_workouts(self):
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get('/api/workouts/')
+        self.assertEqual(response.status_code, 200)
\ No newline at end of file
diff --git a/backend/secfit/integrationtests/testhighscore.py b/backend/secfit/integrationtests/testhighscore.py
new file mode 100644
index 0000000..e6c70f7
--- /dev/null
+++ b/backend/secfit/integrationtests/testhighscore.py
@@ -0,0 +1,59 @@
+from django.test import TestCase
+from rest_framework.test import APIClient, force_authenticate
+from users.models import User
+
+import util
+
+class TestHighScore(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+
+        self.exercise_count = 15
+        util.create_exercises(self.exercise_count)
+
+        util.create_user('tyrion')
+        self.user1 = User.objects.get(username='tyrion')
+        self.user1_workout_instances = 5
+        for _ in range(self.user1_workout_instances):
+            util.create_workout(self.user1)
+
+        util.create_user('arya')
+        self.user2 = User.objects.get(username='arya')
+        self.user2_workout_instances = 2
+        for _ in range(self.user2_workout_instances):
+            util.create_workout(self.user2)
+
+    def test_get_highscores(self):
+        self.client.force_authenticate(user=self.user1)
+        response = self.client.get('/api/highscores/')
+
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        highscores = data['count']
+
+        self.assertEqual(highscores, 2)
+
+    def test_get_highscore_for_non_existing_exercise(self):
+        self.client.force_authenticate(user=self.user1)
+        response = self.client.get('/api/highscores/?exercise=2')
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results = len(data['results'])
+        self.assertEqual(results, 0)
+
+    def test_get_highscore_for_exercise(self):
+        self.client.force_authenticate(user=self.user1)
+        response = self.client.get('/api/highscores/?exercise=1')
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results = data['results']
+        for res in results:
+            if res['username'] == 'tyrion':
+                self.assertEqual(res['score'],  self.user1_workout_instances)
+            elif res['username'] == 'arya':
+                self.assertEqual(res['score'],  self.user2_workout_instances)
+            else:
+                raise Exception("No user match")
diff --git a/backend/secfit/integrationtests/testprofile.py b/backend/secfit/integrationtests/testprofile.py
new file mode 100644
index 0000000..c1e52b3
--- /dev/null
+++ b/backend/secfit/integrationtests/testprofile.py
@@ -0,0 +1,36 @@
+from django.test import TestCase
+from rest_framework.test import APIClient, force_authenticate
+from users.models import User
+
+import util
+
+class TestProfile(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+
+        util.create_user('tyrion')
+        util.create_user('arya')
+        self.user = User.objects.get(username='tyrion')
+
+    def test_get_user_data_not_authenticated(self):
+        response = self.client.get('/api/users/?user=current')
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+
+        self.assertEqual(data['count'], 0)
+
+    def test_get_user_data(self):
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get('/api/users/?user=current')
+
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+
+        self.assertEqual(data['count'], 1)
+
+        user_data = data['results'][0]
+
+        self.assertEqual(user_data['username'], 'tyrion')
+        self.assertEqual(user_data['email'], 'tyrion@lannister.com')
diff --git a/backend/secfit/integrationtests/tests.py b/backend/secfit/integrationtests/tests.py
deleted file mode 100644
index 8a97aaf..0000000
--- a/backend/secfit/integrationtests/tests.py
+++ /dev/null
@@ -1,224 +0,0 @@
-from django.test import TestCase
-from django.utils import timezone
-from rest_framework.test import APIClient, force_authenticate
-from users.models import User
-from users.serializers import UserSerializer
-from workouts.models import Exercise
-from workouts.serializers import ExerciseSerializer, WorkoutSerializer
-
-
-def create_user_data(**kwargs):
-    data = {
-        "username": "",
-        "email": "",
-        "password": "",
-        "password1": "",
-        "phone_number": "",
-        "country": "",
-        "city": "",
-        "street_address": "",
-    }
-    for key, val in kwargs.items():
-        if key in data:
-            data[key] = val
-    return data
-
-
-def create_exercise_data(**kwargs):
-    data = {
-        "name": "",
-        "description": "",
-        "unit": "",
-    }
-    for key, val in kwargs.items():
-        if key in data:
-            data[key] = val
-    return data
-
-
-def create_workout_data(**kwargs):
-    data = {
-        "owner": "",
-        "name": "",
-        "date": timezone.now(),
-        "notes": "",
-        "visibility": "",
-        "exercise_instances": ""
-    }
-    for key, val in kwargs.items():
-        if key in data:
-            data[key] = val
-    return data
-
-
-class TestFiltering(TestCase):
-
-    @staticmethod
-    def create_user(username='tyrion'):
-        user_serializer = UserSerializer()
-        valid_data = create_user_data(
-            username=username,
-            email="tyrion@lannister.com",
-            password="iDrInKaNdIkNoWtHiNgS",
-            password1="iDrInKaNdIkNoWtHiNgS",
-        )
-        user_serializer.create(valid_data)
-
-    @staticmethod
-    def create_exercises(amount):
-        # create >10 exercise types for pagination testing
-        exerciseSerializer = ExerciseSerializer()
-        for i in range(amount):
-            valid_data = create_exercise_data(
-                name="Squats" + str(i),
-                description="Bend knees" + str(i),
-                unit="kg"
-            )
-            exerciseSerializer.create(valid_data)
-
-    @staticmethod
-    def create_workout(user):
-        workoutSerializer = WorkoutSerializer()
-        test = Exercise.objects.get(id="1")
-        valid_data = create_workout_data(
-            owner=user,
-            name="Super big hard workout",
-            notes="It was easy",
-            visibility="PU",
-            exercise_instances=[{
-                "exercise": test,
-                "sets": 123,
-                "number": 123
-            }]
-        )
-        workoutSerializer.create(valid_data)
-
-    def setUp(self):
-        self.client = APIClient()
-
-        self.create_user()
-
-        self.exercise_count = 15
-        self.create_exercises(self.exercise_count)
-
-        self.user = User.objects.get(username='tyrion')
-        self.create_workout(self.user)
-
-    def test_get_exercise_types(self):
-        self.client.force_authenticate(user=self.user)
-        response = self.client.get('/api/exercises/')
-
-        self.assertEqual(response.status_code, 200)
-        data = response.json()
-
-        self.assertEqual(data['count'], self.exercise_count)
-        self.assertGreater(len(data['results']), 0)
-
-    def test_exercise_types_pagination(self):
-        self.client.force_authenticate(user=self.user)
-        response = self.client.get('/api/exercises/')
-
-        self.assertEqual(response.status_code, 200)
-
-        data = response.json()
-        results_count = len(data['results'])
-        response = self.client.get(data['next'])
-
-        self.assertEqual(response.status_code, 200)
-
-        data = response.json()
-        results_count += len(data['results'])
-
-        self.assertEqual(results_count, self.exercise_count)
-
-    def test_get_workouts(self):
-        self.client.force_authenticate(user=self.user)
-        response = self.client.get('/api/workouts/')
-        self.assertEqual(response.status_code, 200)
-
-
-class TestHighScore(TestCase):
-    def setUp(self):
-        self.client = APIClient()
-
-        self.exercise_count = 15
-        TestFiltering.create_exercises(self.exercise_count)
-
-        TestFiltering.create_user()
-        self.user1 = User.objects.get(username='tyrion')
-        self.user1_workout_instances = 5
-        for _ in range(self.user1_workout_instances):
-            TestFiltering.create_workout(self.user1)
-
-        TestFiltering.create_user(username='arya')
-        self.user2 = User.objects.get(username='arya')
-        self.user2_workout_instances = 1
-        for _ in range(self.user2_workout_instances):
-            TestFiltering.create_workout(self.user2)
-
-    def test_get_highscores(self):
-        self.client.force_authenticate(user=self.user1)
-        response = self.client.get('/api/highscores/')
-
-        self.assertEqual(response.status_code, 200)
-
-        data = response.json()
-        highscores = data['count']
-
-        self.assertEqual(highscores, 2)
-
-    def test_get_highscore_for_non_existing_exercise(self):
-        self.client.force_authenticate(user=self.user1)
-        response = self.client.get('/api/highscores/?exercise=2')
-        self.assertEqual(response.status_code, 200)
-
-        data = response.json()
-        results = len(data['results'])
-        self.assertEqual(results, 0)
-
-    def test_get_highscore_for_exercise(self):
-        self.client.force_authenticate(user=self.user1)
-        response = self.client.get('/api/highscores/?exercise=1')
-        self.assertEqual(response.status_code, 200)
-
-        data = response.json()
-        results = data['results']
-        for res in results:
-            if res['username'] == 'tyrion':
-                self.assertEqual(res['score'],  self.user1_workout_instances)
-            elif res['username'] == 'arya':
-                self.assertEqual(res['score'],  self.user2_workout_instances)
-            else:
-                raise Exception("No user match")
-
-
-class TestProfile(TestCase):
-    def setUp(self):
-        self.client = APIClient()
-
-        TestFiltering.create_user()
-        TestFiltering.create_user(username='arya')
-        self.user = User.objects.get(username='tyrion')
-
-    def test_get_user_data_not_authenticated(self):
-        response = self.client.get('/api/users/?user=current')
-        self.assertEqual(response.status_code, 200)
-
-        data = response.json()
-
-        self.assertEqual(data['count'], 0)
-
-    def test_get_user_data(self):
-        self.client.force_authenticate(user=self.user)
-        response = self.client.get('/api/users/?user=current')
-
-        self.assertEqual(response.status_code, 200)
-
-        data = response.json()
-
-        self.assertEqual(data['count'], 1)
-
-        user_data = data['results'][0]
-
-        self.assertEqual(user_data['username'], 'tyrion')
-        self.assertEqual(user_data['email'], 'tyrion@lannister.com')
diff --git a/backend/secfit/integrationtests/util.py b/backend/secfit/integrationtests/util.py
new file mode 100644
index 0000000..8a2e282
--- /dev/null
+++ b/backend/secfit/integrationtests/util.py
@@ -0,0 +1,91 @@
+from django.utils import timezone
+from users.serializers import UserSerializer
+from workouts.serializers import ExerciseSerializer, WorkoutSerializer
+from workouts.models import Exercise
+
+from django.test import TestCase
+from rest_framework.test import APIClient, force_authenticate
+from users.models import User
+
+def create_user_data(**kwargs):
+    data = {
+        "username": "",
+        "email": "",
+        "password": "",
+        "password1": "",
+        "phone_number": "",
+        "country": "",
+        "city": "",
+        "street_address": "",
+    }
+    for key, val in kwargs.items():
+        if key in data:
+            data[key] = val
+    return data
+
+
+def create_exercise_data(**kwargs):
+    data = {
+        "name": "",
+        "description": "",
+        "unit": "",
+    }
+    for key, val in kwargs.items():
+        if key in data:
+            data[key] = val
+    return data
+
+
+def create_workout_data(**kwargs):
+    data = {
+        "owner": "",
+        "name": "",
+        "date": timezone.now(),
+        "notes": "",
+        "visibility": "",
+        "exercise_instances": ""
+    }
+    for key, val in kwargs.items():
+        if key in data:
+            data[key] = val
+    return data
+
+
+def create_user(username):
+    user_serializer = UserSerializer()
+    valid_data = create_user_data(
+        username=username,
+        email="tyrion@lannister.com",
+        password="iDrInKaNdIkNoWtHiNgS",
+        password1="iDrInKaNdIkNoWtHiNgS",
+    )
+    user_serializer.create(valid_data)
+
+
+def create_exercises(amount):
+    # create >10 exercise types for pagination testing
+    exerciseSerializer = ExerciseSerializer()
+    for i in range(amount):
+        valid_data = create_exercise_data(
+            name="Squats" + str(i),
+            description="Bend knees" + str(i),
+            unit="kg"
+        )
+        exerciseSerializer.create(valid_data)
+
+
+def create_workout(user):
+    workoutSerializer = WorkoutSerializer()
+    test = Exercise.objects.get(id="1")
+    valid_data = create_workout_data(
+        owner=user,
+        name="Super big hard workout",
+        notes="It was easy",
+        visibility="PU",
+        exercise_instances=[{
+            "exercise": test,
+            "sets": 123,
+            "number": 123
+        }]
+    )
+    workoutSerializer.create(valid_data)
-- 
GitLab


From ab0aecad22c3cee875c8aa60b5b521780fdeeb7f Mon Sep 17 00:00:00 2001
From: Andreas <andrerim@stud.ntnu.no>
Date: Sun, 14 Mar 2021 20:36:01 +0100
Subject: [PATCH 7/9] Add new line

---
 backend/secfit/integrationtests/testfilter.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/backend/secfit/integrationtests/testfilter.py b/backend/secfit/integrationtests/testfilter.py
index ad5fb0d..11a46f4 100644
--- a/backend/secfit/integrationtests/testfilter.py
+++ b/backend/secfit/integrationtests/testfilter.py
@@ -4,6 +4,7 @@ from users.models import User
 
 import util
 
+
 class TestFiltering(TestCase):
     def setUp(self):
         self.client = APIClient()
@@ -45,4 +46,4 @@ class TestFiltering(TestCase):
     def test_get_workouts(self):
         self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/workouts/')
-        self.assertEqual(response.status_code, 200)
\ No newline at end of file
+        self.assertEqual(response.status_code, 200)
-- 
GitLab


From 5b8fc2af1fd3ba981d6bcde2dc46bbbba255e06c Mon Sep 17 00:00:00 2001
From: Andreas <andrerim@stud.ntnu.no>
Date: Sun, 14 Mar 2021 23:21:38 +0100
Subject: [PATCH 8/9] Add test for ranking

---
 .../secfit/integrationtests/testhighscore.py  | 33 ++++++++++++++++---
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/backend/secfit/integrationtests/testhighscore.py b/backend/secfit/integrationtests/testhighscore.py
index e6c70f7..c4ea1fe 100644
--- a/backend/secfit/integrationtests/testhighscore.py
+++ b/backend/secfit/integrationtests/testhighscore.py
@@ -4,6 +4,7 @@ from users.models import User
 
 import util
 
+
 class TestHighScore(TestCase):
     def setUp(self):
         self.client = APIClient()
@@ -17,12 +18,18 @@ class TestHighScore(TestCase):
         for _ in range(self.user1_workout_instances):
             util.create_workout(self.user1)
 
-        util.create_user('arya')
-        self.user2 = User.objects.get(username='arya')
+        util.create_user('jamie')
+        self.user2 = User.objects.get(username='jamie')
         self.user2_workout_instances = 2
         for _ in range(self.user2_workout_instances):
             util.create_workout(self.user2)
 
+        util.create_user('arya')
+        self.user3 = User.objects.get(username='arya')
+        self.user3_workout_instances = 3
+        for _ in range(self.user3_workout_instances):
+            util.create_workout(self.user3)
+
     def test_get_highscores(self):
         self.client.force_authenticate(user=self.user1)
         response = self.client.get('/api/highscores/')
@@ -32,7 +39,7 @@ class TestHighScore(TestCase):
         data = response.json()
         highscores = data['count']
 
-        self.assertEqual(highscores, 2)
+        self.assertEqual(highscores, 3)
 
     def test_get_highscore_for_non_existing_exercise(self):
         self.client.force_authenticate(user=self.user1)
@@ -50,10 +57,28 @@ class TestHighScore(TestCase):
 
         data = response.json()
         results = data['results']
+
         for res in results:
             if res['username'] == 'tyrion':
                 self.assertEqual(res['score'],  self.user1_workout_instances)
-            elif res['username'] == 'arya':
+            elif res['username'] == 'jamie':
                 self.assertEqual(res['score'],  self.user2_workout_instances)
+            elif res['username'] == 'arya':
+                self.assertEqual(res['score'],  self.user3_workout_instances)
             else:
                 raise Exception("No user match")
+
+    def test_highscore_ranking(self):
+        self.client.force_authenticate(user=self.user1)
+        response = self.client.get('/api/highscores/?exercise=1')
+        self.assertEqual(response.status_code, 200)
+
+        data = response.json()
+        results = data['results']
+        firstplace = results[0]['username']
+        secondplace = results[1]['username']
+        thirdplace = results[2]['username']
+
+        self.assertEqual(firstplace, 'tyrion')
+        self.assertEqual(secondplace, 'arya')
+        self.assertEqual(thirdplace, 'jamie')
-- 
GitLab


From 382ac40f20a04b032faa20e928ca04c201747cde Mon Sep 17 00:00:00 2001
From: andrerim <andreasrim@gmail.com>
Date: Mon, 15 Mar 2021 16:19:19 +0100
Subject: [PATCH 9/9] Refactor tests

---
 backend/secfit/integrationtests/testhighscore.py |  9 +++++----
 backend/secfit/integrationtests/testprofile.py   | 16 +++++++---------
 backend/secfit/integrationtests/util.py          |  2 +-
 3 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/backend/secfit/integrationtests/testhighscore.py b/backend/secfit/integrationtests/testhighscore.py
index c4ea1fe..9c897ab 100644
--- a/backend/secfit/integrationtests/testhighscore.py
+++ b/backend/secfit/integrationtests/testhighscore.py
@@ -33,12 +33,10 @@ class TestHighScore(TestCase):
     def test_get_highscores(self):
         self.client.force_authenticate(user=self.user1)
         response = self.client.get('/api/highscores/')
-
         self.assertEqual(response.status_code, 200)
 
         data = response.json()
-        highscores = data['count']
-
+        highscores = len(data['results'])
         self.assertEqual(highscores, 3)
 
     def test_get_highscore_for_non_existing_exercise(self):
@@ -66,7 +64,10 @@ class TestHighScore(TestCase):
             elif res['username'] == 'arya':
                 self.assertEqual(res['score'],  self.user3_workout_instances)
             else:
-                raise Exception("No user match")
+                self.assertFalse(
+                    True,
+                    "User requested does not exist. Add users to test dataset"
+                )
 
     def test_highscore_ranking(self):
         self.client.force_authenticate(user=self.user1)
diff --git a/backend/secfit/integrationtests/testprofile.py b/backend/secfit/integrationtests/testprofile.py
index c1e52b3..9634581 100644
--- a/backend/secfit/integrationtests/testprofile.py
+++ b/backend/secfit/integrationtests/testprofile.py
@@ -4,33 +4,31 @@ from users.models import User
 
 import util
 
+
 class TestProfile(TestCase):
     def setUp(self):
         self.client = APIClient()
 
         util.create_user('tyrion')
         util.create_user('arya')
-        self.user = User.objects.get(username='tyrion')
+        self.user = User.objects.get(username='arya')
 
     def test_get_user_data_not_authenticated(self):
         response = self.client.get('/api/users/?user=current')
         self.assertEqual(response.status_code, 200)
 
         data = response.json()
-
         self.assertEqual(data['count'], 0)
 
     def test_get_user_data(self):
         self.client.force_authenticate(user=self.user)
         response = self.client.get('/api/users/?user=current')
-
         self.assertEqual(response.status_code, 200)
 
         data = response.json()
+        results = data['results']
+        self.assertEqual(len(results), 1)
 
-        self.assertEqual(data['count'], 1)
-
-        user_data = data['results'][0]
-
-        self.assertEqual(user_data['username'], 'tyrion')
-        self.assertEqual(user_data['email'], 'tyrion@lannister.com')
+        user_data = results[0]
+        self.assertEqual(user_data['username'], 'arya')
+        self.assertEqual(user_data['email'], 'arya@lannister.com')
diff --git a/backend/secfit/integrationtests/util.py b/backend/secfit/integrationtests/util.py
index 8a2e282..b689e01 100644
--- a/backend/secfit/integrationtests/util.py
+++ b/backend/secfit/integrationtests/util.py
@@ -55,7 +55,7 @@ def create_user(username):
     user_serializer = UserSerializer()
     valid_data = create_user_data(
         username=username,
-        email="tyrion@lannister.com",
+        email=f"{username}@lannister.com",
         password="iDrInKaNdIkNoWtHiNgS",
         password1="iDrInKaNdIkNoWtHiNgS",
     )
-- 
GitLab