1265 lines
42 KiB
Python
1265 lines
42 KiB
Python
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
|
|
from django.test import RequestFactory
|
|
|
|
#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
|
|
from rowers.views import addmanual_view, virtualevent_compare_view
|
|
|
|
from django.contrib.messages.storage.fallback import FallbackStorage
|
|
from django.contrib.sessions.middleware import SessionMiddleware
|
|
|
|
from base64 import b64encode
|
|
import base64
|
|
|
|
|
|
from django.core.files.base import File
|
|
from io import BytesIO
|
|
|
|
from PIL import Image
|
|
from io import StringIO
|
|
|
|
from django.core.files.uploadedfile import InMemoryUploadedFile
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
|
|
def create_image(storage, filename, size=(100, 100), image_mode='RGB', image_format='PNG'):
|
|
"""
|
|
Generate a test image, returning the filename that it was saved as.
|
|
|
|
If ``storage`` is ``None``, the BytesIO containing the image data
|
|
will be passed instead.
|
|
"""
|
|
data = BytesIO()
|
|
Image.new(image_mode, size).save(data, image_format)
|
|
data.seek(0)
|
|
if not storage:
|
|
return data
|
|
image_file = ContentFile(
|
|
b64encode(data.read())
|
|
)
|
|
return storage.save(filename, image_file)
|
|
|
|
@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, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='coach')
|
|
|
|
self.u2 = UserFactory()
|
|
self.r2 = Rower.objects.create(user=self.u2,
|
|
birthdate=datetime.datetime.now()-datetime.timedelta(days=28*365),
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='basic')
|
|
|
|
self.u3 = UserFactory()
|
|
self.follower = Rower.objects.create(user=self.u3,
|
|
birthdate=datetime.datetime.now()-datetime.timedelta(days=28*365),
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='basic')
|
|
|
|
|
|
|
|
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 = arrow.get(nu).datetime
|
|
self.wthyro.date = nu.date()
|
|
self.wthyro.save()
|
|
|
|
result = get_random_file(filename='rowers/tests/testdata/thyro.csv')
|
|
self.wthyro2 = WorkoutFactory(user=self.r2,
|
|
csvfilename=result['filename'],
|
|
starttime=result['starttime'],
|
|
startdatetime=result['startdatetime'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
workouttype = 'water',
|
|
)
|
|
|
|
|
|
result = get_random_file(filename='rowers/tests/testdata/thyro.csv')
|
|
self.wthyro3 = WorkoutFactory(user=self.r2,
|
|
csvfilename=result['filename'],
|
|
starttime=result['starttime'],
|
|
startdatetime=result['startdatetime'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
workouttype = 'water',
|
|
)
|
|
|
|
self.wthyro2.startdatetime = arrow.get(nu).datetime
|
|
self.wthyro2.date = nu.date()
|
|
self.wthyro2.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()
|
|
|
|
flw = VirtualRaceFollower.objects.create(race=self.SpeedOrder,
|
|
user=self.u3,
|
|
emailaddress='bla@bla.com')
|
|
|
|
self.result = VirtualRaceResult(
|
|
userid = self.u2.id,
|
|
username = self.u2.username,
|
|
race = self.SpeedOrder,
|
|
distance = 300,
|
|
duration = datetime.time(0,1,20),
|
|
points = 75,
|
|
coursecompleted = True,
|
|
age = 28,
|
|
startsecond = 0,
|
|
endsecond = 120,
|
|
workoutid = self.wthyro2.id
|
|
)
|
|
self.result.save()
|
|
|
|
self.FastestRace = VirtualRace(
|
|
name='Thyro 5K',
|
|
startdate=startdate,
|
|
preferreddate = startdate,
|
|
start_time = start_time,
|
|
enddate=enddate,
|
|
end_time=end_time,
|
|
sessionvalue=200,
|
|
comment='',
|
|
sessiontype = 'fastest_distance',
|
|
timezone=timezone_str,
|
|
evaluation_closure=evaluation_closure,
|
|
registration_closure=registration_closure,
|
|
contact_phone=contact_phone,
|
|
contact_email=contact_email,
|
|
manager=self.u,
|
|
)
|
|
self.FastestRace.save()
|
|
|
|
self.result = VirtualRaceResult(
|
|
userid = self.u2.id,
|
|
username = self.u2.username,
|
|
race = self.FastestRace,
|
|
distance = 300,
|
|
duration = datetime.time(0,1,20),
|
|
points = 75,
|
|
coursecompleted = True,
|
|
age = 28,
|
|
startsecond = 0,
|
|
endsecond = 120,
|
|
workoutid = self.wthyro3.id
|
|
)
|
|
self.result.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),2)
|
|
|
|
lat_lon = (0, 0)
|
|
races = VirtualRace.objects.all()
|
|
traces = getnearestraces(lat_lon,races)
|
|
self.assertEqual(len(traces),2)
|
|
|
|
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_coursemapcompare_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('course_mapcompare_view',kwargs={'id':self.ThyroBaantje.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_coursecompare_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('course_compare_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_fastestrace_view(self):
|
|
login = self.c.login(username=self.u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
race = self.FastestRace
|
|
|
|
if self.r.birthdate:
|
|
age = calculate_age(self.r.birthdate)
|
|
else:
|
|
age = 25
|
|
|
|
# look at event
|
|
url = reverse('virtualevent_view',kwargs={'id':race.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# register
|
|
url = reverse('virtualevent_register_view',kwargs={'id':race.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
form_data = {
|
|
'teamname': 'ApeTeam',
|
|
'boatclass': 'water',
|
|
'boattype': '1x',
|
|
'weightcategory': 'hwt',
|
|
'adaptiveclass': 'None',
|
|
'age': age,
|
|
'mix': False,
|
|
'acceptsocialmedia': True,
|
|
}
|
|
form = VirtualRaceResultForm(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)
|
|
|
|
# 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)
|
|
|
|
records = IndoorVirtualRaceResult.objects.filter(userid=self.u.id)
|
|
self.assertEqual(len(records),1)
|
|
|
|
record = records[0]
|
|
|
|
|
|
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)
|
|
|
|
|
|
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_course_view(self, mocked_myqueue):
|
|
login = self.c.login(username=self.u, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('workout_summary_edit_view',kwargs={'id':encoder.encode_hex(self.wthyro.id)})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
|
|
formdata = {
|
|
'course': self.ThyroBaantje.id
|
|
}
|
|
|
|
form = CourseSelectForm(formdata)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url, formdata, follow=True)
|
|
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()
|
|
|
|
# map compare
|
|
url = reverse('virtualevent_mapcompare_view',kwargs={'id':race.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# compare
|
|
url = reverse('virtualevent_compare_view',kwargs={'id':race.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# workout_mapcompare
|
|
url = reverse('workout_course_view', kwargs={'id':encoder.encode_hex(self.wthyro.id)})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
# post to compare
|
|
form_data = {
|
|
'workouts':[self.wthyro2.id],
|
|
'xparam': 'distance',
|
|
'yparam': 'spm',
|
|
'plottype': 'line',
|
|
'teamid':0,
|
|
'course':self.ThyroBaantje.id,
|
|
}
|
|
form = ChartParamChoiceForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = WorkoutMultipleCompareForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
# post2 to compare
|
|
form_data = {
|
|
'xparam': 'distance',
|
|
'yparam': 'spm',
|
|
'plottype': 'line',
|
|
'teamid':0,
|
|
'course':self.ThyroBaantje.id
|
|
}
|
|
form = ChartParamChoiceForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
request = self.factory.post(url,
|
|
data=form_data)
|
|
|
|
# adding session
|
|
get_response = MagicMock()
|
|
middleware = SessionMiddleware(get_response)
|
|
middleware.process_request(request)
|
|
request.session.save()
|
|
|
|
session = request.session
|
|
session['ids'] = [self.wthyro2.id]
|
|
session.save()
|
|
|
|
request.user = self.u
|
|
response = virtualevent_compare_view(request,id=str(race.id))
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
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)
|
|
|
|
|
|
def test_virtualevent_check_view(self):
|
|
|
|
res = tasks.handle_check_race_course(
|
|
self.wthyro.csvfilename,
|
|
self.wthyro.id,
|
|
self.ThyroBaantje.id,
|
|
self.result.id,
|
|
self.wthyro.user.user.email,
|
|
self.wthyro.user.user.first_name,
|
|
)
|
|
|
|
self.assertEqual(res,1)
|
|
|
|
|
|
# add boat
|
|
|
|
|
|
@override_settings(TESTING=True)
|
|
class IndoorChallengesTest(TestCase):
|
|
@staticmethod
|
|
def get_image_file(name, ext='png', size=(50, 50), color=(256, 0, 0)):
|
|
file_obj = BytesIO()
|
|
image = Image.new("RGBA", size=size, color=color)
|
|
image.save(file_obj, ext)
|
|
file_obj.seek(0)
|
|
return File(file_obj, name=name)
|
|
|
|
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, ftpset=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 = arrow.get(nu).datetime
|
|
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=int(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.dataprep.create_engine')
|
|
def test_upload_manual(self, mocked_sqlalchemy):
|
|
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)
|
|
|
|
# submit result (manual)
|
|
|
|
image = self.get_image_file('image.jpg')
|
|
|
|
form_data = {
|
|
'name': faker.word(),
|
|
'date': nu.date().strftime("%Y-%m-%d"),
|
|
'starttime': '10:01:43',
|
|
'timezone': 'UTC',
|
|
'duration': '00:02:00.0',
|
|
'distance': race.sessionvalue,
|
|
'workouttype': 'rower',
|
|
'boattype': '1x',
|
|
'weightcategory': 'hwt',
|
|
'adaptiveclass': 'None',
|
|
'notes': faker.text(),
|
|
'rankingpiece': True,
|
|
'empowerside': 'port',
|
|
'boatname': 'Dolfijn',
|
|
'seatnumber': 1,
|
|
'duplicate': False,
|
|
'avghr': '160',
|
|
'avgpwr': 0,
|
|
'rpe':4,
|
|
'avgspm': 40,
|
|
}
|
|
|
|
form = MetricsForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = WorkoutForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
file_data = {'file':image}
|
|
|
|
form = ImageForm(form_data,file_data)
|
|
|
|
self.assertTrue(form.is_valid())
|
|
|
|
url = '/rowers/workout/addmanual/'+str(race.id)+'/'
|
|
response = self.c.get(url)
|
|
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
|
|
#form_data['file'] = image
|
|
request = self.factory.post(url,
|
|
data=form_data,
|
|
files={'file':image},
|
|
)
|
|
setattr(request, 'session', 'session')
|
|
messages = FallbackStorage(request)
|
|
setattr(request, '_messages', messages)
|
|
|
|
request.user = self.u
|
|
|
|
response = addmanual_view(request,raceid=str(race.id))
|
|
|
|
expected = reverse('virtualevent_view',kwargs={'id':race.id})
|
|
|
|
self.assertEqual(response.status_code,302)
|
|
self.assertEqual(response.url,expected)
|
|
|
|
|
|
|
|
|
|
@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)
|