coverage related changes

rowers/tests/test_api.py

@@ -0,0 +1,185 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+from django.db import transaction
+
+#from __future__ import print_function
+from .statements import *
+nu = datetime.datetime.now()
+
+
+import rowers
+from rowers import dataprep
+from rowers import tasks
+from rowers import c2stuff
+from rowers import stravastuff
+import urllib
+import json
+import pandas as pd
+from rowers.opaque import encoder
+
+from rest_framework.test import APIRequestFactory, force_authenticate
+
+import json
+
+from rowers.ownapistuff import *
+from rowers.views.apiviews import *
+
+class OwnApi(TestCase):
+    def setUp(self):
+        self.u = UserFactory()
+
+        self.r = Rower.objects.create(user=self.u,
+                                      birthdate=faker.profile()['birthdate'],
+                                      gdproptin=True,surveydone=True,
+                                      gdproptindate=timezone.now(),
+                                      rowerplan='coach',subscription_id=1)
+
+        workoutsbox = Mailbox.objects.create(name='workouts')
+        workoutsbox.save()
+        failbox = Mailbox.objects.create(name='Failed')
+        failbox.save()
+
+        self.c = Client()
+        self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
+        self.factory = RequestFactory()
+        self.password = faker.word()
+        self.u.set_password(self.password)
+        self.u.save()
+
+        self.factory = APIRequestFactory()
+
+
+    def test_strokedataform(self):
+        login = self.c.login(username=self.u.username, password=self.password)
+        self.assertTrue(login)
+
+        w = self.user_workouts[0]
+
+        url = reverse('strokedataform',kwargs={'id':encoder.encode_hex(w.id)})
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+        url = reverse('strokedatajson',kwargs={'id':w.id})
+
+        request = self.factory.get(url)
+        request.user = self.u
+        force_authenticate(request, user=self.u)
+        response = strokedatajson(request,id=w.id)
+        self.assertEqual(response.status_code,200)
+
+        # response must be json
+        strokedata = json.loads(response.content)
+        df = pd.DataFrame(strokedata)
+        self.assertFalse(df.empty)
+
+        form_data = {
+            "distance": [23, 46, 48],
+            "time": [3200, 6700, 10099],
+            "spm": [16.4, 21.2, 19.8],
+            "pace": [155068, 144402, 138830],
+            "power": [84.6, 117.2, 141.3],
+            "hr": [85, 91, 95]
+              }
+
+        result = get_random_file(filename='rowers/tests/testdata/thyro.csv')
+        w2 = Workout.objects.create(
+            user=self.r,
+            csvfilename=result['filename'],
+            duration=result['duration'],
+            startdatetime=result['startdatetime'],
+            workouttype='water',
+            starttime=result['starttime'],
+            )
+
+        url = reverse('strokedatajson',kwargs={'id':w2.id})
+
+        request = self.factory.post(url,{'strokedata':form_data},format='json')
+        request.user = self.u
+        request.data = json.dumps({'strokedata':form_data})
+        strokedata = json.loads(request.data)['strokedata']
+
+        force_authenticate(request, user=self.u)
+        with patch('rowers.dataprep.getrowdata_db') as mock_getrowdata:
+            mock_getrowdata.return_value = (pd.DataFrame(),None)
+            response = strokedatajson(request,id=w.id)
+            self.assertEqual(response.status_code,201)
+
+    def test_strokedataform_v2(self):
+        login = self.c.login(username=self.u.username, password=self.password)
+        self.assertTrue(login)
+
+        w = self.user_workouts[0]
+
+        url = reverse('strokedataform_v2',kwargs={'id':encoder.encode_hex(w.id)})
+        response = self.c.get(url)
+        self.assertEqual(response.status_code,200)
+
+        url = reverse('strokedatajson_v2',kwargs={'id':w.id})
+
+        request = self.factory.get(url)
+        request.user = self.u
+        force_authenticate(request, user=self.u)
+        response = strokedatajson_v2(request,id=w.id)
+        self.assertEqual(response.status_code,200)
+
+        # response must be json
+        strokedata = json.loads(response.content)
+        df = pd.DataFrame(strokedata)
+        self.assertFalse(df.empty)
+
+
+        form_data = {
+            "data": [
+                {
+                    "time": 3200.0000476837,
+                    "pace": 155068.4885951763,
+                    "hr": 85.7857142857,
+                    "power": 84.6531131591,
+                    "distance": 23,
+                    "spm": 16.380952381
+                    },
+                    {
+                    "time": 6700.0000476837,
+                    "pace" : 144402.6407586741,
+                    "hr": 91.2142857143,
+                    "power": 117.458827834,
+                    "distance": 36,
+                    "spm": 21.1666666667
+                    },
+                    {
+                    "time": 10099.9999046326,
+                    "pace": 138830.8712654931,
+                    "hr": 95.7142857143,
+                    "power": 141.31057207,
+                    "distance": 48,
+                    "spm": 19.8095238095
+                    }
+                    ]
+                    }
+
+
+        result = get_random_file(filename='rowers/tests/testdata/thyro.csv')
+        w2 = Workout.objects.create(
+            user=self.r,
+            csvfilename=result['filename'],
+            duration=result['duration'],
+            startdatetime=result['startdatetime'],
+            workouttype='water',
+            starttime=result['starttime'],
+            )
+
+        url = reverse('strokedatajson_v2',kwargs={'id':w2.id})
+
+        request = self.factory.post(url,form_data,format='json')
+        request.user = self.u
+        request.data = json.dumps(form_data)
+
+        force_authenticate(request, user=self.u)
+        with patch('rowers.dataprep.getrowdata_db') as mock_getrowdata:
+            mock_getrowdata.return_value = (pd.DataFrame(),None)
+            response = strokedatajson_v2(request,id=w.id)
+
+            self.assertEqual(response.status_code,200)

rowers/tests/test_courses.py

@@ -4,6 +4,122 @@ from __future__ import print_function
 from __future__ import unicode_literals
 
 from .statements import *
+import rowers.courses as courses
+import rowers.dataprep as dataprep
+from rowers.courseutils import *
+from rowingdata import rowingdata as rdata
+from rowers.models import polygon_to_path
+
+class CourseUnitTest(TestCase):
+    def setUp(self):
+        self.c = Client()
+        self.u = User.objects.create_user('john',
+                                     'sander@ds.ds',
+                                     'koeinsloot')
+        self.r = Rower.objects.create(user=self.u,gdproptin=True,surveydone=True,
+                                      gdproptindate=timezone.now(),
+                                      rowerplan='coach',
+        )
+        self.nu = datetime.datetime.now()
+
+        cs = courses.kmltocourse('rowers/tests/testdata/thyro.kml')
+        course = cs[0]
+        cname = course['name']
+        cnotes = course['description']
+        self.polygons = course['polygons']
+        pstart = self.polygons[0]
+        self.ThyroBaantje = courses.createcourse(self.r,cname,self.polygons,notes=cnotes)
+        self.start = GeoPolygon.objects.filter(course=self.ThyroBaantje,order_in_course=0)[0]
+        self.ThyroBaantje.save()
+
+        result = get_random_file(filename='rowers/tests/testdata/thyro.csv')
+        self.wthyro = WorkoutFactory(user=self.r,
+                                 csvfilename=result['filename'],
+                                 starttime=result['starttime'],
+                                 startdatetime=result['startdatetime'],
+                                 duration=result['duration'],
+                                 distance=result['totaldist'],
+                                 workouttype = 'water',
+                                 )
+
+        self.wthyro.startdatetime = arrow.get(self.nu).datetime
+        self.wthyro.date = self.nu.date()
+        self.wthyro.save()
+
+    def test_time_in_path(self):
+        row = rdata(csvfile='rowers/tests/testdata/thyro.csv')
+
+        time = row.df['TimeStamp (sec)']
+        lat = row.df[' latitude']
+        lon = row.df[' longitude']
+        cum_dist = row.df['cum_dist']
+
+        data = pd.DataFrame(
+            {
+                'time':time,
+                'latitude':lat,
+                'longitude':lon,
+                'cum_dist':cum_dist,
+                }
+        )
+
+        startpath = polygon_to_path(self.start)
+
+        mintime,mindist = time_in_path(data,startpath)
+        self.assertEqual(mintime,78)
+        self.assertEqual(mindist,207.1)
+
+    def test_coursetime_first(self):
+        row = rdata(csvfile='rowers/tests/testdata/thyro.csv')
+
+        time = row.df['TimeStamp (sec)']
+        lat = row.df[' latitude']
+        lon = row.df[' longitude']
+        cum_dist = row.df['cum_dist']
+
+        data = pd.DataFrame(
+            {
+                'time':time,
+                'latitude':lat,
+                'longitude':lon,
+                'cum_dist':cum_dist,
+                }
+        )
+        paths = []
+        polygons = GeoPolygon.objects.filter(course=self.ThyroBaantje).order_by("order_in_course")
+        for p in polygons:
+            paths.append(polygon_to_path(p))
+
+        entrytime,entrydistance,coursecompleted = coursetime_first(data,paths)
+        self.assertEqual(entrytime,78)
+        self.assertEqual(entrydistance,207.1)
+        self.assertTrue(coursecompleted)
+
+    def test_coursetime_paths(self):
+        row = rdata(csvfile='rowers/tests/testdata/thyro.csv')
+
+        time = row.df['TimeStamp (sec)']
+        lat = row.df[' latitude']
+        lon = row.df[' longitude']
+        cum_dist = row.df['cum_dist']
+
+        data = pd.DataFrame(
+            {
+                'time':time,
+                'latitude':lat,
+                'longitude':lon,
+                'cum_dist':cum_dist,
+                }
+        )
+        paths = []
+        polygons = GeoPolygon.objects.filter(course=self.ThyroBaantje).order_by("order_in_course")
+        for p in polygons:
+            paths.append(polygon_to_path(p))
+
+        entrytime,entrydistance,coursecompleted = coursetime_paths(data,paths)
+        self.assertEqual(entrytime,435)
+        self.assertEqual(entrydistance,1348.8)
+        self.assertTrue(coursecompleted)
 
 class CoursesTest(TestCase):
     def setUp(self):