rowsandall/rowers/tests/test_courses.py

from __future__ import absolute_import
from __future__ import division
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, ftpset=True,surveydone=True,
                                      gdproptindate=timezone.now(),
                                      rowerplan='coach',
        )
        self.nu = datetime.datetime.now()

        with open('rowers/tests/testdata/thyro.kml') as f:
            cs = courses.kmltocourse(f)
        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):
        self.c = Client()
        self.u = User.objects.create_user('john',
                                     'sander@ds.ds',
                                     'koeinsloot')
        self.r = Rower.objects.create(user=self.u,gdproptin=True, ftpset=True,surveydone=True,
                                      gdproptindate=timezone.now(),
                                      rowerplan='coach',
        )
        self.nu = datetime.datetime.now()


    def test_courses(self):
        login = self.c.login(username='john',password='koeinsloot')
        self.assertTrue(login)

        filename = 'rowers/tests/testdata/Courses.kml'
        with open(filename,'rb') as f:
            file_data = {'file': f}
            form_data = {
                'name': 'test courses',
                'notes': 'aap nn',
                'file':f,
            }

            courseform = CourseForm(form_data)
            self.assertTrue(courseform.is_valid())

            response = self.c.get('/rowers/courses/upload/')
            self.assertTrue(response.status_code,200)

            response = self.c.post('/rowers/courses/upload/', form_data, follow=True)



        self.assertRedirects(response, expected_url='/rowers/list-courses/',
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)


        response = self.c.get('/rowers/list-courses/')
        self.assertEqual(response.status_code, 200)

        response = self.c.get('/rowers/courses/1/edit/')
        self.assertEqual(response.status_code, 200)

        response = self.c.get('/rowers/courses/1/')
        self.assertEqual(response.status_code, 200)

        response = self.c.get('/rowers/courses/1/map/')
        self.assertEqual(response.status_code, 200)

        form_data = {
            'name':'apekoers',
            'country':'United States of Atlantis',
            'notes':'nota bene'
            }

        form = GeoCourseEditForm(form_data)
        self.assertTrue(form.is_valid())

        response = self.c.post('/rowers/courses/1/edit/',form_data)
        self.assertTrue(response.status_code,200)

        response = self.c.get('/rowers/courses/1/downloadkml/')
        self.assertEqual(response.status_code,200)

        self.assertEqual(
            response.get('Content-Disposition'),
            'attachment; filename="course_1.kml"'
            )