rowsandall/rowers/tests/test_races.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

#from __future__ import print_function
from .statements import *
nu = datetime.datetime.now()

from rowers.utils import allmonths,allsundays

import rowers.plannedsessions as plannedsessions
import rowers.courses as courses
import rowers.tasks as tasks
from rowers.views.racesviews import *
from rowers.utils import calculate_age

@override_settings(TESTING=True)
class ChallengesTest(TestCase):
    def setUp(self):
        self.u = UserFactory()

        self.r = Rower.objects.create(user=self.u,
                                      birthdate=datetime.datetime.now()-datetime.timedelta(days=25*365),
                                      gdproptin=True,surveydone=True,
                                      gdproptindate=timezone.now(),
                                      rowerplan='coach')

        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()

        cs = courses.kmltocourse('rowers/tests/testdata/thyro.kml')
        course = cs[0]
        cname = course['name']
        cnotes = course['description']
        polygons = course['polygons']
        self.ThyroBaantje = courses.createcourse(self.r,cname,polygons,notes=cnotes)
        self.ThyroBaantje.save()

        id = save_scoring('Standard Scoring',self.u,'rowers/tests/testdata/coursestandard.csv',id=0)
        self.Scoring = StandardCollection.objects.get(id=id)

        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 = nu
        self.wthyro.date = nu.date()
        self.wthyro.save()

        startdate = arrow.get(datetime.datetime.now()-datetime.timedelta(days=1)).datetime
        start_time = datetime.time()
        enddate = startdate+datetime.timedelta(days=5)
        end_time = start_time
        evaluation_closure = startdate+datetime.timedelta(days=6)
        registration_closure = evaluation_closure
        contact_phone = '06342323'
        contact_email = 'roosendaalsander@gmail.com'

        timezone_str = 'UTC'

        self.SpeedOrder = VirtualRace(
            name='Thyro Speed Order',
            startdate=startdate,
            preferreddate = startdate,
            start_time = start_time,
            enddate=enddate,
            end_time=end_time,
            course=self.ThyroBaantje,
            comment='',
            sessiontype = 'race',
            timezone=timezone_str,
            evaluation_closure=evaluation_closure,
            registration_closure=registration_closure,
            contact_phone=contact_phone,
            coursestandards=self.Scoring,
            contact_email=contact_email,
            country = 'Netherlands',
            manager=self.u,
        )
        self.SpeedOrder.save()


    def tearDown(self):
        for workout in self.user_workouts:
            try:
                os.remove(workout.csvfilename)
            except (IOError, FileNotFoundError,OSError):
                pass

    def test_distance(self):
        lat_lon = (52.214229145558484, 6.890036546847821)
        distance = howfaris(lat_lon,self.ThyroBaantje)
        distance = int(100*distance)
        self.assertEqual(distance,315)

    def test_getnearestraces(self):
        lat_lon = (52.214229145558484, 6.890036546847821)
        races = VirtualRace.objects.all()
        traces = getnearestraces(lat_lon,races)
        self.assertEqual(len(traces),1)

        lat_lon = (0, 0)
        races = VirtualRace.objects.all()
        traces = getnearestraces(lat_lon,races)
        self.assertEqual(len(traces),1)

    def test_getnearestcourses(self):
        lat_lon = (52.214229145558484, 6.890036546847821)
        courses = [self.ThyroBaantje]
        tcourses = getnearestcourses(lat_lon,courses)
        self.assertEqual(len(tcourses),1)

        lat_lon = (0, 0)
        courses = [self.ThyroBaantje]
        tcourses = getnearestcourses(lat_lon,courses)
        self.assertEqual(len(tcourses),1)

    def test_courses_view(self):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        url = reverse('courses_view')
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

    def test_standards_view(self):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        url = reverse('standards_view')
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

    def test_coursemap_view(self):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        url = reverse('course_map_view',kwargs={'id':self.ThyroBaantje.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

    def test_course_create_edit_delete(self):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        # Create
        url = reverse('course_upload_view')
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)


        filename = 'rowers/tests/testdata/alphen.kml'
        f = open(filename,'r')

        file_data = {'file': f}
        form_data = {
            'name':'Alphen',
            'notes': 'aa',
            'country': 'Netherlands',
            'file':f,
        }

        form = CourseForm(form_data,file_data)
        response = self.c.post(url,form_data,follow=True)
        f.close()

        expected_url = reverse('courses_view')

        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        courses = GeoCourse.objects.all()

        self.assertEqual(len(courses),2)

        Alphen = GeoCourse.objects.get(id=2)

        # edit
        # edit
        url = reverse('course_edit_view',kwargs={'id':Alphen.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'name':'Alphen',
            'country': 'NL',
            'notes': 'bb'
        }

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

        response = self.c.post(url,form_data)
        self.assertEqual(response.status_code,200)

        # check
        url = reverse('course_view',kwargs={'id':Alphen.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)


        # Upload new kml
        url = reverse('course_upload_replace_view',kwargs={'id':self.ThyroBaantje.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        filename = 'rowers/tests/testdata/thyro2.kml'
        f = open(filename,'r')

        file_data = {'file': f}
        form_data = {
            'name':'Thyro modified',
            'notes': 'aa',
            'country': 'Netherlands',
            'file':f,
        }

        form = CourseForm(form_data,file_data)
        response = self.c.post(url,form_data,follow=True)
        f.close()

        expected_url = reverse('course_update_confirm',kwargs={'id':self.ThyroBaantje.id,'newid':3})

        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        url = expected_url
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'doupdate': True,
        }

        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('course_view',kwargs={'id':3})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)


        # KML Download
        url = reverse('course_kmldownload_view',kwargs={'id':Alphen.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        # delete
        url = reverse('course_delete_view',kwargs={'id':Alphen.id})
        response = self.c.get(url,follow=True)
        expected_url = reverse('courses_view')

        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

    def test_standard_view(self):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        # Download
        url = reverse('standards_download_view',kwargs={'id':1})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        # Deactivate
        url = reverse('standard_deactivate_view',kwargs={'id':1})
        response = self.c.get(url,follow=True)
        expected_url = reverse('standards_view')
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)
        self.assertEqual(response.status_code,200)

        # Create Charles
        url = reverse('standards_upload_view')
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)


        filename = 'rowers/tests/testdata/charles.csv'
        f = open(filename,'r')

        file_data = {'file': f}
        form_data = {
            'name':'Alphen',
            'notes': 'aa',
            'file':f,
        }

        form = StandardsForm(form_data,file_data)
        response = self.c.post(url,form_data,follow=True)
        f.close()

        expected_url = reverse('standard_view',kwargs={'id':2})

        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

    def test_virtualevents_view(self):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        # check virtual events
        url = reverse('virtualevents_view')
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'upcoming',
        }

        # make various selections
        form = VirtualRaceSelectForm(form_data)
        self.assertTrue(form.is_valid())

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'previous',
        }

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

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'ongoing',
        }

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

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'my',
        }

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

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

    @patch('rowers.views.racesviews.myqueue')
    def test_virtualevent_view(self,mocked_myqueue):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        race = self.SpeedOrder
        # look at event
        url = reverse('virtualevent_view',kwargs={'id':race.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        (
            hasinitial,
            boattype,
            boatclass,
            adaptiveclass,
            weightclass,
            sex,
            referencespeed,
            initialcategory
            ) = plannedsessions.default_class(self.r,None,race)
        self.assertTrue(hasinitial)

        if self.r.birthdate:
            age = calculate_age(self.r.birthdate)
        else:
            age = 25

        # register
        url = reverse('virtualevent_register_view',kwargs={'id':race.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        categories = CourseStandard.objects.filter(standardcollection=race.coursestandards).order_by("name")

        form_data = {
            'teamname': 'ApeTeam',
            'boattype': boattype,
            'boatclass': boatclass,
            'weightcategory': weightclass,
            'adaptiveclass': adaptiveclass,
            'age': age,
            'mix': False,
            'acceptsocialmedia': True,
            'entrycategory':initialcategory.id,
        }
        form = VirtualRaceResultForm(form_data,categories=categories)
        self.assertTrue(form.is_valid())


        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        # toggle email
        url = reverse('virtualevent_toggle_email_view',kwargs={'id':race.id})
        response = self.c.get(url,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)
        self.assertEqual(response.status_code,200)

        records = VirtualRaceResult.objects.filter(userid=self.u.id)
        self.assertEqual(len(records),1)

        record = records[0]

        # ranking
        url = reverse('virtualevent_ranking_view',kwargs={'id':race.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        # add boat
        url = reverse('virtualevent_addboat_view',kwargs={'id':race.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        categories = CourseStandard.objects.filter(standardcollection=race.coursestandards).order_by("name")
        thecategory = categories.filter(
            agemin=initialcategory.agemin,
            agemax=initialcategory.agemax,
            boatclass='water',
            boattype='2x',
            sex=initialcategory.sex,
            weightclass=initialcategory.weightclass,
            adaptiveclass=initialcategory.adaptiveclass,
            skillclass=initialcategory.skillclass
            )

        self.assertTrue(len(thecategory),1)
        thecategory = thecategory[0]

        form_data = {
            'teamname': 'ApeTeam',
            'boattype': boattype,
            'boatclass': boatclass,
            'weightcategory': weightclass,
            'adaptiveclass': adaptiveclass,
            'age': age,
            'mix': False,
            'acceptsocialmedia': True,
            'entrycategory':thecategory.id,
        }
        form = VirtualRaceResultForm(form_data,categories=categories)
        self.assertTrue(form.is_valid())


        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        # withdraw
        url = reverse('virtualevent_withdrawresult_view',kwargs={'id':race.id,'recordid':record.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'message':'zo niet he',
            'reason':'suspicious'
        }
        form = DisqualificationForm(form_data)
        self.assertTrue(form.is_valid())

        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        form_data = {
            'teamname': 'ApeTeam',
            'boattype': boattype,
            'boatclass': boatclass,
            'weightcategory': weightclass,
            'adaptiveclass': adaptiveclass,
            'age': age,
            'mix': False,
            'acceptsocialmedia': True,
            'entrycategory':initialcategory.id,
        }

        # register again
        url = reverse('virtualevent_register_view',kwargs={'id':race.id})
        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        records = VirtualRaceResult.objects.filter(userid=self.u.id)
        self.assertEqual(len(records),2)

        record = records[0]

        # edit entry
        url = reverse('virtualevent_entry_edit_view',kwargs={'id':race.id,'entryid':record.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)
        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        records = VirtualRaceResult.objects.filter(userid=self.u.id)
        self.assertEqual(len(records),2)

        record = records[0]

        # submit workout
        url = reverse('virtualevent_submit_result_view',kwargs={'id':race.id,'workoutid':self.wthyro.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code, 200)

        form_data = {
            'workouts':[self.wthyro.id],
            'record':record.id,
        }

        response = self.c.post(url,form_data,follow=True)
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        records = VirtualRaceResult.objects.filter(userid=self.u.id)
        self.assertEqual(len(records),2)

        record = records[0]
        record.workoutid = self.wthyro.id
        record.save()

        url = reverse('virtualevent_disqualify_view',kwargs={'id':race.id,'recordid':record.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'message':'zo niet he',
            'reason':'suspicious'
        }
        form = DisqualificationForm(form_data)
        self.assertTrue(form.is_valid())

        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        url = reverse('virtualevent_results_download_view',kwargs={'id':race.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        # add follower
        url = reverse('addfollower_view',kwargs={'id':race.id})
        response = self.c.get(url,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)


        # add boat


@override_settings(TESTING=True)
class IndoorChallengesTest(TestCase):
    def setUp(self):
        self.u = UserFactory()

        self.r = Rower.objects.create(user=self.u,
                                      birthdate=datetime.datetime.now()-datetime.timedelta(days=25*365),
                                      gdproptin=True,surveydone=True,
                                      gdproptindate=timezone.now(),
                                      rowerplan='coach')

        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()

        id = save_scoring('Standard Scoring',self.u,'rowers/tests/testdata/coursestandard.csv',id=0)
        self.Scoring = StandardCollection.objects.get(id=id)


        result = get_random_file(filename='rowers/tests/testdata/2019-01-13_session.csv',
                                 name='sprintervals')

        self.werg = WorkoutFactory(user=self.r,
                                     csvfilename=result['filename'],
                                     starttime=result['starttime'],
                                     startdatetime=result['startdatetime'],
                                     duration=result['duration'],
                                     distance=result['totaldist'],
                                     workouttype = 'water',
                                     )

        self.werg.startdatetime = nu
        self.werg.date = nu.date()
        self.werg.save()

        startdate = arrow.get(datetime.datetime.now()-datetime.timedelta(days=1)).datetime
        start_time = datetime.time()
        enddate = startdate+datetime.timedelta(days=5)
        end_time = start_time
        evaluation_closure = startdate+datetime.timedelta(days=6)
        registration_closure = evaluation_closure
        contact_phone = '06342323'
        contact_email = 'roosendaalsander@gmail.com'

        timezone_str = 'UTC'

        self.IndoorSpeedOrder = VirtualRace(
            name='Thyro Speed Order',
            startdate=startdate,
            preferreddate = startdate,
            start_time = start_time,
            enddate=enddate,
            end_time=end_time,
            comment='',
            sessiontype = 'indoorrace',
            timezone=timezone_str,
            evaluation_closure=evaluation_closure,
            registration_closure=registration_closure,
            contact_phone=contact_phone,
            contact_email=contact_email,
            country = 'Netherlands',
            manager=self.u,
            sessionvalue=result['totaldist'],
            sessionunit='m',
            sessionmode='distance',
        )
        self.IndoorSpeedOrder.save()


    def tearDown(self):
        for workout in self.user_workouts:
            try:
                os.remove(workout.csvfilename)
            except (IOError, FileNotFoundError,OSError):
                pass


    def test_virtualevents_view(self):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        # check virtual events
        url = reverse('virtualevents_view')
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'upcoming',
        }

        # make various selections
        form = VirtualRaceSelectForm(form_data)
        self.assertTrue(form.is_valid())

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'previous',
        }

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

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'ongoing',
        }

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

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

        form_data = {
            'country':'All',
            'regattatype':'my',
        }

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

        response = self.c.post(url)
        self.assertEqual(response.status_code,200)

    @patch('rowers.views.racesviews.myqueue')
    def test_virtualevent_view(self,mocked_myqueue):
        login = self.c.login(username=self.u.username, password=self.password)
        self.assertTrue(login)

        race = self.IndoorSpeedOrder
        # look at event
        url = reverse('virtualevent_view',kwargs={'id':race.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)

        if self.r.birthdate:
            age = calculate_age(self.r.birthdate)
        else:
            age = 25

        # register
        url = reverse('indoorvirtualevent_register_view',kwargs={'id':race.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)


        form_data = {
            'teamname': 'ApeTeam',
            'boatclass': 'rower',
            'weightcategory': 'hwt',
            'adaptiveclass': 'None',
            'age': age,
            'mix': False,
            'acceptsocialmedia': True,
        }
        form = IndoorVirtualRaceResultForm(form_data)

        self.assertTrue(form.is_valid())


        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        # toggle email
        url = reverse('indoorvirtualevent_toggle_email_view',kwargs={'id':race.id})
        response = self.c.get(url,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)
        self.assertEqual(response.status_code,200)

        records = IndoorVirtualRaceResult.objects.filter(userid=self.u.id)
        self.assertEqual(len(records),1)

        record = records[0]

        # withdraw
        url = reverse('virtualevent_withdrawresult_view',kwargs={'id':race.id,'recordid':record.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code,200)


        # register again
        url = reverse('indoorvirtualevent_register_view',kwargs={'id':race.id})
        response = self.c.post(url,form_data,follow=True)
        expected_url = reverse('virtualevent_view',kwargs={'id':race.id})
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)

        records = IndoorVirtualRaceResult.objects.filter(userid=self.u.id)
        self.assertEqual(len(records),1)

        record = records[0]

        # submit workout
        url = reverse('virtualevent_submit_result_view',kwargs={'id':race.id,'workoutid':self.werg.id})
        response = self.c.get(url)
        self.assertEqual(response.status_code, 200)

        form_data = {
            'workouts':[self.werg.id],
            'record':record.id,
        }

        response = self.c.post(url,form_data,follow=True)
        self.assertRedirects(response, expected_url=expected_url,
                             status_code=302,target_status_code=200)

        self.assertEqual(response.status_code, 200)