def test_calc_times(self):
        self.r.save()

        sess = Session()
        sess.name = "AM"
        sess.event = self.e
        sess.club = self.c
        sess.save()

        res = Result()
        res.reg = self.r
        res.session = sess
        res.club = self.c
        res.save()

        r = Run()
        r.base_time = 10.0
        r.result = res
        r.club = self.c
        r.save()

        res = Result()
        res.reg = self.r
        res.session = sess
        res.club = self.c
        res.save()

        r = Run()
        r.base_time = 10.0
        r.result = res
        r.club = self.c
        r.save()

        self.r.save()
        self.r.calc_times()

        self.assertEqual(self.r.total_raw_time, 20.0)
        self.assertEqual(self.r.total_index_time,
                         self.r.total_raw_time * self.race_class.pax)
    def test_calc_times(self):
        self.r.save()

        sess = Session()
        sess.name = "AM"
        sess.event = self.e
        sess.club = self.c
        sess.save()

        res = Result()
        res.reg = self.r
        res.session = sess
        res.club = self.c
        res.save()

        r = Run()
        r.base_time = 10.0
        r.result = res
        r.club = self.c
        r.save()

        res = Result()
        res.reg = self.r
        res.session = sess
        res.club = self.c
        res.save()

        r = Run()
        r.base_time = 10.0
        r.result = res
        r.club = self.c
        r.save()

        self.r.save()
        self.r.calc_times()

        self.assertEqual(self.r.total_raw_time, 20.0)
        self.assertEqual(self.r.total_index_time, self.r.total_raw_time * self.race_class.pax)
Пример #3
0
 def test_no_dibs(self): 
     reg = Registration()
     up = UserProfile.objects.get(user=self.u1)
     reg.user_profile = up
     reg.number = 15
     reg.race_class = self.race_class
     reg.pax_class = None
     reg.event = self.e4
     reg.club = self.c
     reg.save()   
     
     s = Session()
     s.event = self.e4
     s.name = "AM"
     s.club = self.c
     s.save()
     
     result = Result()
     result.reg = reg
     result.session = s
     result.club = self.c
     result.save()
     
     for k in range(0, 3):
         r = Run()
         r.base_time = 10.0
         r.calc_time = 10.0
         r.index_time = 10.0
         r.result = result
         r.club = self.c
         r.save()        
     
     self.c.assign_dibs()
     self.assertEqual(len(Dibs.objects.all()), 0) 
                     
     reg.delete()
     s.delete()
Пример #4
0
def upload_results(request, event_id): 
    validate_error = dict()

    event = Event.objects.get(pk=event_id)
    admin = is_club_admin(request.user, event.club)
    if not admin: 
        return HttpResponseForbidden()

    try: 
        name = request.POST.get('name') 
        if not name: 
            validate_error['name'] = "you must name the session"
            raise ValueError

        session = Session()
        session.club = event.club
        session.event = event
        session.save()

        f = StringIO.StringIO(request.FILES['results_file'].read())

        results = parse_axtime(event, session, f)

        if isinstance(results, dict): #some kind of error happened
            validate_error = results
            raise ValueError

        transaction.rollback()    
        return HttpResponse(content=json.dumps({'msg': "success"}), mimetype="application/json", status=200)
        
    except Exception:
        #import traceback
        #tb = traceback.format_exc()
        session.delete()
        transaction.rollback()
        print json.dumps(validate_error)
        return HttpResponse(content=json.dumps(validate_error), mimetype="application/json", status=400)
Пример #5
0
class TestResult(unittest.TestCase):
    def setUp(self):

        self.c = Club()
        self.c.name = "test club"
        self.c.save()

        self.season = Season()
        self.season.club = self.c
        self.season.year = 2011
        self.season.save()

        self.race_class = RaceClass()
        self.race_class.name = "CSP"
        self.race_class.pax = 0.875
        self.race_class.club = self.c
        self.race_class.save()

        self.e = Event()
        self.e.name = "test event"
        self.e.date = datetime.date.today()
        self.e.season = self.season
        self.e.club = self.c
        self.e.save()

        self.sess = Session()
        self.sess.name = "AM"
        self.sess.event = self.e
        self.sess.club = self.c
        self.sess.save()

        self.r = Registration()
        self.r.number = 11
        self.r.race_class = self.race_class
        self.r.pax_class = None
        self.r.event = self.e
        self.r.club = self.c
        self.r.save()

        self.result = Result()
        self.result.reg = self.r
        self.result.session = self.sess
        self.result.club = self.c
        self.result.save()

    def tearDown(self):

        Club.objects.all().delete()
        Season.objects.all().delete()
        RaceClass.objects.all().delete()
        Event.objects.all().delete()
        Session.objects.all().delete()
        Registration.objects.all().delete()
        Result.objects.all().delete()
        Run.objects.all().delete()

    def test_best_run1(self):

        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.club = self.c
        r1.save()

        r2 = Run()
        r2.base_time = 11.0
        r2.result = self.result
        r2.club = self.c
        r2.save()

        r3 = Run()
        r3.base_time = 9.0
        r3.cones = 1
        r3.result = self.result
        r3.club = self.c
        r3.save()

        r4 = Run()
        r4.base_time = 10.0
        r4.result = self.result
        r4.penalty = "DNF"
        r4.club = self.c
        r4.save()

        best_run = self.result.find_best_run()

        self.assertEqual(best_run, r1)

    def test_best_run2(self):

        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.club = self.c
        r1.save()

        best_run = self.result.find_best_run()

        self.assertEqual(best_run, r1)

    def test_best_run3(self):

        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.club = self.c
        r1.save()

        r2 = Run()
        r2.base_time = 9.0
        r2.result = self.result
        r2.club = self.c
        r2.save()

        r3 = Run()
        r3.base_time = 10.5
        r3.result = self.result
        r3.club = self.c
        r3.save()

        best_run = self.result.find_best_run()

        self.assertEqual(best_run, r2)

    def test_best_run_no_clean_runs(self):

        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.penalty = "DNF"
        r1.club = self.c
        r1.save()

        r2 = Run()
        r2.base_time = 0.1
        r2.result = self.result
        r2.penalty = "O/C"
        r2.club = self.c
        r2.save()

        best_run = self.result.find_best_run()

        self.assertEqual(best_run, None)
Пример #6
0
 def setUp(self): 
     
     self.today = datetime.date.today()
     
     self.c = Club()
     self.c.name = "test"
     self.c.events_for_dibs = 2
     self.c.save()
     
     self.race_class = RaceClass()
     self.race_class.name = "CSP"
     self.race_class.pax = .875
     self.race_class.club = self.c
     self.race_class.save()
     
     self.s = Season()
     self.s.year = 2011
     self.s.club = self.c
     self.s.save()
     
     self.e1 = Event()
     self.e1.name = "event1"
     self.e1.date = self.today-datetime.timedelta(days=10)
     self.e1.season = self.s
     self.e1.club = self.c
     self.e1.save()
     
     self.e2 = Event()
     self.e2.name = "event2"
     self.e2.date = self.today-datetime.timedelta(days=8)
     self.e2.season = self.s
     self.e2.club = self.c
     self.e2.save()
     
     self.e3 = Event()
     self.e3.name = "event3"
     self.e3.date = self.today-datetime.timedelta(days=5)
     self.e3.season = self.s
     self.e3.club = self.c
     self.e3.save()
     
     self.e4 = Event()
     self.e4.name = "event4"
     self.e4.date = self.today+datetime.timedelta(days=10)
     self.e4.season = self.s
     self.e4.club = self.c
     self.e4.save()
     
     self.events = [self.e1, self.e2, self.e3]       
     
     for event in self.events: 
         s = Session()
         s.event = event
         s.name = "AM"
         s.club = self.c
         s.save()
     
     self.u1 = User()
     self.u1.username = "******"
     self.u1.save()
     
     self.u2 = User()
     self.u2.username = "******"
     self.u2.save()
     
     self.u3 = User()
     self.u3.username = "******"
     self.u3.save()
     
     self.users = [self.u1, self.u2, self.u3]
     
     for i, user in enumerate(self.users): 
         up = user.get_profile()
         for j, event in enumerate(self.events): 
             if j<=i: 
                 r = Registration()
                 r.number = "%d"%(i+1)
                 r.race_class = self.race_class
                 r.pax_class = None
                 r.event = event    
                 r.user_profile = up
                 r.club = self.c
                 r.save()
                 
                 result = Result()
                 result.reg = r
                 result.session = event.sessions.all()[0]
                 result.club = self.c
                 result.save()
                 
                 for k in range(0, 3):
                     r = Run()
                     r.base_time = 10.0
                     r.calc_time = 10.0
                     r.index_time = 10.0
                     r.result = result
                     r.club = self.c
                     r.save()
Пример #7
0
class TestResult(unittest.TestCase): 
    
    def setUp(self): 
        
        self.c = Club()
        self.c.name = "test club"
        self.c.save()
        
        self.season = Season()
        self.season.club = self.c
        self.season.year = 2011
        self.season.save()
        
        self.race_class = RaceClass()
        self.race_class.name = "CSP"
        self.race_class.pax = .875
        self.race_class.club = self.c
        self.race_class.save()
        
        self.e = Event()
        self.e.name = "test event"
        self.e.date = datetime.date.today()
        self.e.season = self.season
        self.e.club = self.c
        self.e.save()
        
        self.sess = Session()
        self.sess.name = "AM"
        self.sess.event = self.e
        self.sess.club = self.c
        self.sess.save()
        
        self.r = Registration()
        self.r.number = 11
        self.r.race_class = self.race_class
        self.r.pax_class = None
        self.r.event = self.e
        self.r.club = self.c
        self.r.save()
        
        self.result = Result()
        self.result.reg = self.r
        self.result.session = self.sess
        self.result.club = self.c
        self.result.save()
        
    def tearDown(self): 
        
        Club.objects.all().delete()
        Season.objects.all().delete()
        RaceClass.objects.all().delete()
        Event.objects.all().delete()
        Session.objects.all().delete()
        Registration.objects.all().delete()
        Result.objects.all().delete()
        Run.objects.all().delete()
    
    def test_best_run1(self): 
        
        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.club = self.c
        r1.save()
        
        r2 = Run()
        r2.base_time = 11.0
        r2.result = self.result
        r2.club = self.c
        r2.save()
        
        r3 = Run()
        r3.base_time = 9.0
        r3.cones = 1
        r3.result = self.result
        r3.club = self.c
        r3.save()
        
        r4 = Run()
        r4.base_time = 10.0
        r4.result = self.result
        r4.penalty = "DNF"
        r4.club = self.c
        r4.save()
        
        best_run = self.result.find_best_run()
        
        self.assertEqual(best_run, r1)
        
    def test_best_run2(self): 
        
        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.club = self.c
        r1.save()
        
        best_run = self.result.find_best_run() 
        
        self.assertEqual(best_run, r1)   
        
    def test_best_run3(self): 
        
        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.club = self.c
        r1.save()
        
        r2 = Run()
        r2.base_time = 9.0
        r2.result = self.result
        r2.club = self.c
        r2.save()
        
        r3 = Run()
        r3.base_time = 10.5
        r3.result = self.result
        r3.club = self.c
        r3.save()
        
        best_run = self.result.find_best_run() 
        
        self.assertEqual(best_run, r2) 
        
    def test_best_run_no_clean_runs(self): 
        
        r1 = Run()
        r1.base_time = 10.0
        r1.result = self.result
        r1.penalty = "DNF"
        r1.club = self.c
        r1.save()
        
        r2 = Run()
        r2.base_time = 0.1
        r2.result = self.result
        r2.penalty = "O/C"
        r2.club = self.c
        r2.save()
        
        best_run = self.result.find_best_run() 
        
        self.assertEqual(best_run, None)        
class TestParseAxtime(TestCase):
    def setUp(self):
        self.data = [
            '"First","Last","Reg","Class","Num","BC","Vehicle","Addr","City_St","Zip","Heat","Wrk_Ht","Wrk_Asgn","Notes","Mem_Num","Pax_Cls","Color","Sponsor","Tires","Co_Drvr","In_Pts","DL_Num","DL_St","DL_Exp","Fee","Pd_by","Run1_1","Pyl1_1","Pen1_1","Run2_1","Pyl2_1","Pen2_1","Run3_1","Pyl3_1","Pen3_1","Run4_1","Pyl4_1","Pen4_1","Run5_1","Pyl5_1","Pen5_1","Best_1","Run1_2","Pyl1_2","Pen1_2","Run2_2","Pyl2_2","Pen2_2","Run3_2","Pyl3_2","Pen3_2","Run4_2","Pyl4_2","Pen4_2","Run5_2","Pyl5_2","Pen5_2","Best_2","Pts_1","Pts_2","Pts_3","Pts_4","Pts_5","Pts_6","Pts_7","Pts_8","Pts_9","Pts_10","Pts_11","Pts_12","Pts_13","Pts_14","Pts_15","Pts_Bon","Indx_1","Indx_2","Indx_3","Indx_4","Indx_5","Indx_6","Indx_7","Indx_8","Indx_9","Indx_10","Indx_11","Indx_12","Indx_13","Indx_14","Indx_15","Indx_Bon"',
            '"CHRIS","BRUBAKER","NORA","STS","73","","97 MAZDA MIATA","","   ","     ","  1","  2","","22906","BRUBAKER","STS","","","","","Y","","  ","","   ","  ","  55.531"," 0","   ","  55.436"," 0","   ","  53.677"," 0","   ","  54.566"," 0","   ","   0.000"," 0","   ","  53.677","  53.873"," 0","   ","  54.056"," 0","   ","  53.792"," 0","   ","  53.803"," 0","   ","   0.000"," 0","   ","  53.792","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    "'
        ]

        self.c = Club()
        self.c.name = "test"
        self.c.save()

        self.s = Season()
        self.s.year = 2011
        self.s.club = self.c
        self.s.save()

        self.e = Event()
        self.e.name = "test event"
        self.e.date = datetime.date.today()
        self.e.season = self.s
        self.e.club = self.c
        self.e.save()

        self.session = Session()
        self.session.name = "am"
        self.session.club = self.c
        self.session.event = self.e
        self.session.save()

        self.rc = RaceClass()
        self.rc.name = "STS"
        self.rc.abrv = "STS"
        self.rc.pax = .95
        self.rc.club = self.c
        self.rc.save()

        self.rc2 = RaceClass()
        self.rc2.name = "Rookie"
        self.rc2.abrv = "R"
        self.rc2.pax = 1
        self.rc2.club = self.c
        self.rc2.pax_class = True
        self.rc2.save()

        self.rc3 = RaceClass()
        self.rc3.name = "STC"
        self.rc3.abrv = "STC"
        self.rc3.pax = .95
        self.rc3.club = self.c
        self.rc3.save()

        user = User.objects.create_user('admin', '*****@*****.**',
                                        'admin')

    def tearDown(self):

        models = [Registration, RaceClass, Club, Season, Event, Session, User]
        for model in models:
            model.objects.all().delete()

    def test_missing_raceclass(self):
        RaceClass.objects.all().delete()

        f = StringIO.StringIO("\n".join(self.data))

        results = parse_axtime(self.e, self.session, f)

        self.assertEqual(
            results, {
                'results_file':
                'Your results for CHRIS BRUBAKER included an unknown race class: STS'
            })

    def test_with_raceclass_anon(self):
        f = StringIO.StringIO("\n".join(self.data))

        results = parse_axtime(self.e, self.session, f)

        result = results[0]
        runs = result.runs.all()

        self.assertEqual(len(runs), 8)
        self.assertEqual(result.best_run, runs[2])

        self.assertEqual(result.reg._anon_f_name, 'CHRIS')
        self.assertEqual(result.reg._anon_l_name, 'BRUBAKER')
        self.assertEqual(result.reg.user, AnonymousUser())

    def test_with_raceclass(self):
        f = StringIO.StringIO("\n".join(self.data))

        user = User()
        user.first_name = "CHRIS"
        user.last_name = "brubaker"
        user.username = "******"
        user.save()

        self.r = Registration()
        self.r.number = 11
        self.r.race_class = self.rc
        self.r.pax_class = None
        self.r.club = self.c
        self.r.event = self.e

        result = parse_axtime(self.e, self.session, f)[0]
        runs = result.runs.all()

        self.assertEqual(len(runs), 8)
        self.assertEqual(result.best_run, runs[2])

        reg = result.reg
        self.assertEqual(reg.user, user)

        self.assertEqual(reg.number, 73)

    def test_multi_results(self):
        self.data.append(
            '"CHRIS","MCPHERSON","NORA","R","13","","90 HONDA CIVIC SI","","   ","     ","  1","  2","","22929","SUMMERNIGH","STC","","","","","Y","","  ","","   ","  ","  59.740"," 0","   ","  58.399"," 0","   ","  56.798"," 2","   ","  57.131"," 0","   ","  55.374"," 0","   ","  55.374","  56.671"," 0","   ","  56.519"," 0","   ","  56.225"," 0","   ","  55.629"," 0","   ","   0.000"," 0","   ","  55.629","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    "'
        )
        f = StringIO.StringIO("\n".join(self.data))

        results = parse_axtime(self.e, self.session, f)

        self.assertEqual(len(results), 2)

        result = results[0]
        self.assertEqual(result.reg.race_class, self.rc)
        self.assertEqual(result.reg.pax_class, None)

        result = results[1]
        self.assertEqual(result.reg.race_class, self.rc3)
        self.assertEqual(result.reg.pax_class, self.rc2)

    def base_upload_results(self):

        c = Client()
        c.login(username='******', password='******')

        self.data.append(
            '"CHRIS","MCPHERSON","NORA","R","13","","90 HONDA CIVIC SI","","   ","     ","  1","  2","","22929","SUMMERNIGH","STC","","","","","Y","","  ","","   ","  ","  59.740"," 0","   ","  58.399"," 0","   ","  56.798"," 2","   ","  57.131"," 0","   ","  55.374"," 0","   ","  55.374","  56.671"," 0","   ","  56.519"," 0","   ","  56.225"," 0","   ","  55.629"," 0","   ","   0.000"," 0","   ","  55.629","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    "'
        )
        f = StringIO.StringIO("\n".join(self.data))
        f.name = "results.csv"

        url = "/garage/event/%d/results" % self.e.id

        post_data = {'name': 'AM', 'results_file': f}

        response = c.post(url, post_data)

        return response

    def test_upload_with_error1(self):
        """make sure things work if the first result line is an error"""
        RaceClass.objects.all().delete()
        Session.objects.all().delete()

        response = self.base_upload_results()

        self.assertEqual(
            json.loads(response.content), {
                'results_file':
                'Your results for CHRIS BRUBAKER included an unknown race class: STS'
            })

        runs = Run.objects.all()
        self.assertEqual(len(runs), 0)

        results = Result.objects.all()
        self.assertEqual(len(results), 0)

        sessions = Session.objects.all()
        self.assertEqual(len(sessions), 0)

    def test_upload_with_error2(self):
        """make sure things work if the second result line is an error"""
        RaceClass.objects.exclude(abrv='STS').delete()
        Session.objects.all().delete()

        response = self.base_upload_results()

        self.assertEqual(
            json.loads(response.content), {
                u'result_file':
                u'Your Reults for CHRIS MCPHERSON included a unknown entry, R in the Class column'
            })

        runs = Run.objects.all()
        self.assertEqual(len(runs), 0)

        results = Result.objects.all()
        self.assertEqual(len(results), 0)

        sessions = Session.objects.all()
        self.assertEqual(len(sessions), 0)

    def test_upload_clean(self):
        Session.objects.all().delete()

        response = self.base_upload_results()

        self.assertEqual(response.status_code, 200)

        runs = Run.objects.all()
        self.assertEqual(len(runs), 17)

        results = Result.objects.all()
        self.assertEqual(len(results), 2)

        sessions = Session.objects.all()
        self.assertEqual(len(sessions), 1)
Пример #9
0
class TestEvent(unittest.TestCase): 
    
    def setUp(self): 
        self.c = Club()
        self.c.name = "test"
        self.c.save()
        
        self.s = Season()
        self.s.year = 2011
        self.s.club = self.c
        self.s.save()
        
        self.e = Event()
        self.e.name = "test event"
        self.e.date = datetime.date.today()
        self.e.season = self.s
        self.e.club = self.c
        
    def tearDown(self): 
        clear_db()
               
        
    def testEventSafeName(self): 
        pass
    
    def testEventisRegd(self): 
        
        self.e.save()
        
        u = User()
        u.first_name = "Justin" 
        u.last_name = "Gray"
        u.username = "******"
        
        u.save()
        
        rc = RaceClass()
        rc.abrv = "CSP"
        rc.name = "CSP"
        rc.pax = 1
        rc.club = self.c
        rc.save()
                
        self.assertFalse(self.e.is_regd(u))        
        
        r = Registration()
        r.event = self.e
        r.number = 11
        r.race_class = rc
        r.user_profile = u.get_profile()
        r.club = self.c
        r.save()
        
        self.assertTrue(self.e.is_regd(u))
    
    def testValidRegClose(self): 
        
        try: 
            self.e.reg_close = datetime.datetime.today()+datetime.timedelta(days=1)
            self.e.full_clean()
        except ValidationError as err: 
            self.assertEqual("{'__all__': [u'Registration must close before the date of the event.']}", str(err))
        else: 
            self.fail("ValidationError expected")     
                
    def test_event_reg_limit(self): 
        self.e.save()
        self.sess = Session()
        self.sess.name = "AM"
        self.sess.event = self.e
        self.sess.club = self.c
        self.sess.save()
                
        self.race_class = RaceClass()
        self.race_class.name = "A"
        self.race_class.pax = 1
        self.race_class.club = self.c
        self.race_class.save()        
        
        self.e.reg_limit = 3
        self.e.save()
        
        for i in range(0, 4): 
            try: 
                self.r = Registration()
                self.r.number = i
                self.r.race_class = self.race_class
                self.r._anon_f_name = "random_%d"%(i,)
                self.r.pax_class = None
                self.r.event = self.e
                self.r.club = self.c
                self.r.save()
                
            except ValidationError as err: #don't error untill the limit is reached  
                self.assertEqual(i, 3)
            else: 
                self.assertLess(i, 3)
Пример #10
0
class TestEventPointsCalc(unittest.TestCase): 
    
    def setUp(self): 
        self.c = Club()
        self.c.name = "test club"
        self.c.full_clean()
        self.c.save()
        
        self.season = Season()
        self.season.club = self.c
        self.season.year = 2011
        self.season.save()
        
        self.e = Event()
        self.e.name = "test event"
        self.e.date = datetime.date.today()
        self.e.season = self.season
        self.e.club = self.c
        self.e.save()
        
        self.sess = Session()
        self.sess.name = "AM"
        self.sess.event = self.e
        self.sess.club = self.c
        self.sess.save()
        
        self.classes = ["A", "B", "C", "D", "E", "F", "G", "H"]
        self.paxes   = [1.0, .98, .96, .94, .92, .90, .88, .86]
        for klass, pax in zip(self.classes, self.paxes): 
            self.race_class = RaceClass()
            self.race_class.name = klass
            self.race_class.pax = pax
            self.race_class.club = self.c
            self.race_class.save()
            
            for i in range(0, 10): 
                self.r = Registration()
                self.r.number = i
                self.r.race_class = self.race_class
                self.r._anon_f_name = "%s%d"%(self.race_class.name, i)
                self.r.pax_class = None
                self.r.event = self.e
                self.r.club = self.c
                self.r.save()
                
                #make two regs with empty runs for each class
                if self.race_class.name!="H" and i < 8: #one race class with no results
                    self.result = Result()
                    self.result.reg = self.r
                    self.result.session = self.sess
                    self.result.club = self.c
                    self.result.save()
                    for j in range(0, 3): 
                        run = Run()
                        run.base_time = 100.0-i-j #91.0 is lowest raw time (*0.88 for index)
                        run.result = self.result
                        run.club = self.c
                        run.save()        
                            
    def tearDown(self): 
        clear_db()

    def test_no_index_classes_one_result(self): 
        
        race_classes = self.e.calc_results()
        self.assertEqual(["A", "B", "C", "D", "E", "F", "G"], [rc.name for rc in race_classes])
                
        #make sure the results come back sorted
        for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results    
            self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))

            self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
            
            self.assertEqual(8, len(regs))
            
        regs = self.e.get_results()
        self.assertEqual(regs[0].total_index_time, (91.0)*.88)
        self.assertEqual(index_point_ladder[:56], [reg.index_points for reg in regs])
        
    def test_no_index_classes_two_result(self): 
        
        self.sess = Session()
        self.sess.name = "PM"
        self.sess.event = self.e
        self.sess.club = self.c
        self.sess.save()

        for klass, pax in zip(self.classes, self.paxes): 
            self.race_class = RaceClass.objects.filter(name=klass).get()            
            for i in range(0, 10): 
                self.r = Registration.objects.filter(_anon_f_name="%s%d"%(self.race_class.name, i)).get()
                
                #make  regs with empty runs for each class
                if self.race_class.name!="H" and i < 8: #one race class with no results
                    self.result = Result()
                    self.result.reg = self.r
                    self.result.session = self.sess
                    self.result.club = self.c
                    self.result.save()
                    for j in range(0, 3): 
                        run = Run()
                        run.base_time = 100.0-i-j
                        run.result = self.result
                        run.club = self.c
                        run.save()   
                self.r = Registration.objects.filter(_anon_f_name="%s%d"%(self.race_class.name, i)).get()        
                
        race_classes = self.e.calc_results()
        self.assertEqual(["A", "B", "C", "D", "E", "F", "G"], [rc.name for rc in race_classes])
                
        #make sure the results come back sorted
        for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results    
            self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))

            self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
            
            self.assertEqual(8, len(regs))
            
        regs = self.e.get_results()
        self.assertEqual(regs[0].total_index_time, 2*(91.0)*.88)
        self.assertEqual(index_point_ladder[:56], [reg.index_points for reg in regs])
        
    def test_pax_class_one_result(self): 
        
        self.race_class = RaceClass()
        self.race_class.name = "Pro"
        self.race_class.abrv ="X"
        self.race_class.pax = 1.0
        self.race_class.pax_class=True
        self.race_class.club = self.c
        self.race_class.save()

        for i, pax_name in zip(range(0, 7), self.classes): 
            
            rc = RaceClass.objects.filter(name=pax_name).get()
            
            self.r = Registration()
            self.r.number = 10*(1+i)
            self.r.race_class = rc
            self.r._anon_f_name = "%s_%d"%(self.race_class.name, i)
            self.r.pax_class = self.race_class
            self.r.event = self.e
            self.r.club = self.c
            self.r.save()
            
            #make  regs with runs for each class
            if rc.name!="H": 
                self.result = Result()
                self.result.reg = self.r
                self.result.session = self.sess
                self.result.club = self.c
                self.result.save()
                for j in range(0, 3): 
                    run = Run()
                    run.base_time = 100.0-i-j
                    run.result = self.result
                    run.club = self.c
                    run.save()   
                
        race_classes = self.e.calc_results()
        self.assertEqual([u"A", u"B", u"C", u"D", u"E", u"F", u"G", u"Pro"], [rc.name for rc in race_classes])
                
        #make sure the results come back sorted
        for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results    
            self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))

            if rc.name != "Pro": 
                self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
                self.assertEqual(8, len(regs))
            else: 
                self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
                self.assertEqual(7, len(regs))
                
        regs = self.e.get_results()
        self.assertEqual(regs[0].total_index_time, (91.0)*.88)
        self.assertEqual(index_point_ladder[:63], [reg.index_points for reg in regs])  
        
    def test_one_bump_class_one_result(self): 
        
        self.race_class = RaceClass()
        self.race_class.name = "index"
        self.race_class.pax = 1.0
        self.race_class.club = self.c
        self.race_class.save()

        for i, pax_name in zip(range(0, 7), self.classes): 
            
            rc = RaceClass.objects.filter(name=pax_name).get()
            
            self.r = Registration()
            self.r.number = 10*(1+i)
            self.r.race_class = rc
            self.r._anon_f_name = "%s_%d"%(self.race_class.name, i)
            self.r.bump_class = self.race_class
            self.r.event = self.e
            self.r.club = self.c
            self.r.save()
            
            #make  regs with empty runs for each class
            if rc.name!="H": 
                self.result = Result()
                self.result.reg = self.r
                self.result.session = self.sess
                self.result.club = self.c
                self.result.save()
                for j in range(0, 3): 
                    run = Run()
                    run.base_time = 100.0-i-j
                    run.result = self.result
                    run.club = self.c
                    run.save()   
                
        race_classes = self.e.calc_results()
        self.assertEqual(["A", "B", "C", "D", "E", "F", "G", "index"], [rc.name for rc in race_classes])
                
        #make sure the results come back sorted
        for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results    
            self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))

            if rc.name != "index": 
                self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
                self.assertEqual(8, len(regs))
            else: 
                self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
                self.assertEqual(7, len(regs))
            
        regs = self.e.get_results()
        self.assertEqual(regs[0].total_index_time, (91.0)*.88)
        self.assertEqual(index_point_ladder[:63], [reg.index_points for reg in regs])  
        
    def test_two_bump_class_one_result(self): 
        
        self.race_class1 = RaceClass()
        self.race_class1.name = "index1"
        self.race_class1.pax = 1.0
        self.race_class1.club = self.c
        self.race_class1.save()
        
        self.race_class2 = RaceClass()
        self.race_class2.name = "index2"
        self.race_class2.pax = 1.0
        self.race_class2.club = self.c
        self.race_class2.save()

        for i, pax_name in zip(range(0, 7), self.classes): 
            
            pax_class = RaceClass.objects.filter(name=pax_name).get()
            
            self.r = Registration()
            self.r.number = 10*(1+i)
            self.r.race_class = pax_class
            self.r._anon_f_name = "%s_%d"%(self.race_class2.name, i)
            self.r.bump_class = self.race_class1
            self.r.event = self.e
            self.r.club = self.c
            self.r.save()
            
            #make  regs with empty runs for each class
            if pax_class.name!="H": 
                self.result = Result()
                self.result.reg = self.r
                self.result.session = self.sess
                self.result.club = self.c
                self.result.save()
                for j in range(0, 3): 
                    run = Run()
                    run.base_time = 100.0-i-j
                    run.result = self.result
                    run.club = self.c
                    run.save()  
                    
                self.r = Registration()
                self.r.number = 60*(1+i)
                self.r.race_class = pax_class
                self.r._anon_f_name = "%s_%d"%(self.race_class2.name, i)
                self.r.bump_class = self.race_class2
                self.r.event = self.e
                self.r.club = self.c
                self.r.save()
                
                #make  regs with empty runs for each class
                if pax_class.name!="H": 
                    self.result = Result()
                    self.result.reg = self.r
                    self.result.session = self.sess
                    self.result.club = self.c
                    self.result.save()
                    for j in range(0, 3): 
                        run = Run()
                        run.base_time = 100.0-i-j
                        run.result = self.result
                        run.club = self.c
                        run.save()               
                    
        race_classes = self.e.calc_results()
        self.assertEqual(set(["A", "B", "C", "D", "E", "F", "G", "index1", "index2"]), set([rc.name for rc in race_classes]))
                
        #make sure the results come back sorted
        for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results    
            self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))

            if "index" not in rc.name: 
                self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
                self.assertEqual(8, len(regs))
            else: 
                self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
                self.assertEqual(7, len(regs))
                
        regs = self.e.get_results()
        self.assertEqual(regs[0].total_index_time, (91.0)*.88)
        self.assertEqual(index_point_ladder[:70], [reg.index_points for reg in regs])      
        
        
class TestParseAxtime(TestCase): 

    def setUp(self): 
        self.data = ['"First","Last","Reg","Class","Num","BC","Vehicle","Addr","City_St","Zip","Heat","Wrk_Ht","Wrk_Asgn","Notes","Mem_Num","Pax_Cls","Color","Sponsor","Tires","Co_Drvr","In_Pts","DL_Num","DL_St","DL_Exp","Fee","Pd_by","Run1_1","Pyl1_1","Pen1_1","Run2_1","Pyl2_1","Pen2_1","Run3_1","Pyl3_1","Pen3_1","Run4_1","Pyl4_1","Pen4_1","Run5_1","Pyl5_1","Pen5_1","Best_1","Run1_2","Pyl1_2","Pen1_2","Run2_2","Pyl2_2","Pen2_2","Run3_2","Pyl3_2","Pen3_2","Run4_2","Pyl4_2","Pen4_2","Run5_2","Pyl5_2","Pen5_2","Best_2","Pts_1","Pts_2","Pts_3","Pts_4","Pts_5","Pts_6","Pts_7","Pts_8","Pts_9","Pts_10","Pts_11","Pts_12","Pts_13","Pts_14","Pts_15","Pts_Bon","Indx_1","Indx_2","Indx_3","Indx_4","Indx_5","Indx_6","Indx_7","Indx_8","Indx_9","Indx_10","Indx_11","Indx_12","Indx_13","Indx_14","Indx_15","Indx_Bon"',
                     '"CHRIS","BRUBAKER","NORA","STS","73","","97 MAZDA MIATA","","   ","     ","  1","  2","","22906","BRUBAKER","STS","","","","","Y","","  ","","   ","  ","  55.531"," 0","   ","  55.436"," 0","   ","  53.677"," 0","   ","  54.566"," 0","   ","   0.000"," 0","   ","  53.677","  53.873"," 0","   ","  54.056"," 0","   ","  53.792"," 0","   ","  53.803"," 0","   ","   0.000"," 0","   ","  53.792","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    "'
                    ]

        self.c = Club()
        self.c.name = "test"
        self.c.save()
        
        self.s = Season()
        self.s.year = 2011
        self.s.club = self.c
        self.s.save()
        
        self.e = Event()
        self.e.name = "test event"
        self.e.date = datetime.date.today()
        self.e.season = self.s
        self.e.club = self.c
        self.e.save()

        self.session = Session()
        self.session.name = "am"
        self.session.club = self.c
        self.session.event = self.e
        self.session.save()

        self.rc = RaceClass()
        self.rc.name = "STS"
        self.rc.abrv = "STS"
        self.rc.pax = .95
        self.rc.club = self.c
        self.rc.save()

        self.rc2 = RaceClass()
        self.rc2.name = "Rookie"
        self.rc2.abrv = "R"
        self.rc2.pax = 1
        self.rc2.club = self.c
        self.rc2.pax_class = True
        self.rc2.save()

        self.rc3 = RaceClass()
        self.rc3.name = "STC"
        self.rc3.abrv = "STC"
        self.rc3.pax = .95
        self.rc3.club = self.c
        self.rc3.save()

        user = User.objects.create_user('admin', '*****@*****.**', 'admin')

    def tearDown(self): 

        models = [Registration, RaceClass, Club, Season, Event, Session, User]
        for model in models: 
            model.objects.all().delete()

    def test_missing_raceclass(self): 
        RaceClass.objects.all().delete()

        f = StringIO.StringIO("\n".join(self.data))

        results = parse_axtime(self.e, self.session, f)

        self.assertEqual(results, 
                        {'results_file': 'Your results for CHRIS BRUBAKER included an unknown race class: STS'})
        
    def test_with_raceclass_anon(self):
        f = StringIO.StringIO("\n".join(self.data))

        results = parse_axtime(self.e, self.session, f)
        
        result = results[0]
        runs = result.runs.all()

        self.assertEqual(len(runs), 8)
        self.assertEqual(result.best_run, runs[2])

        self.assertEqual(result.reg._anon_f_name, 'CHRIS')
        self.assertEqual(result.reg._anon_l_name, 'BRUBAKER')
        self.assertEqual(result.reg.user, AnonymousUser())

    def test_with_raceclass(self):
        f = StringIO.StringIO("\n".join(self.data))

        user = User()
        user.first_name = "CHRIS"
        user.last_name = "brubaker"
        user.username = "******"
        user.save()

        self.r = Registration()
        self.r.number = 11
        self.r.race_class = self.rc
        self.r.pax_class = None
        self.r.club = self.c
        self.r.event = self.e

        result = parse_axtime(self.e, self.session, f)[0]
        runs = result.runs.all()
        
        self.assertEqual(len(runs), 8)
        self.assertEqual(result.best_run, runs[2])

        reg = result.reg
        self.assertEqual(reg.user, user)

        self.assertEqual(reg.number, 73)

    def test_multi_results(self): 
        self.data.append('"CHRIS","MCPHERSON","NORA","R","13","","90 HONDA CIVIC SI","","   ","     ","  1","  2","","22929","SUMMERNIGH","STC","","","","","Y","","  ","","   ","  ","  59.740"," 0","   ","  58.399"," 0","   ","  56.798"," 2","   ","  57.131"," 0","   ","  55.374"," 0","   ","  55.374","  56.671"," 0","   ","  56.519"," 0","   ","  56.225"," 0","   ","  55.629"," 0","   ","   0.000"," 0","   ","  55.629","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    "')
        f = StringIO.StringIO("\n".join(self.data))

        results = parse_axtime(self.e, self.session, f)

        self.assertEqual(len(results), 2)

        result = results[0]
        self.assertEqual(result.reg.race_class, self.rc)
        self.assertEqual(result.reg.pax_class, None)

        result = results[1]
        self.assertEqual(result.reg.race_class, self.rc3)
        self.assertEqual(result.reg.pax_class, self.rc2)

    def base_upload_results(self): 
        
        c = Client()
        c.login(username='******', password='******')

        self.data.append('"CHRIS","MCPHERSON","NORA","R","13","","90 HONDA CIVIC SI","","   ","     ","  1","  2","","22929","SUMMERNIGH","STC","","","","","Y","","  ","","   ","  ","  59.740"," 0","   ","  58.399"," 0","   ","  56.798"," 2","   ","  57.131"," 0","   ","  55.374"," 0","   ","  55.374","  56.671"," 0","   ","  56.519"," 0","   ","  56.225"," 0","   ","  55.629"," 0","   ","   0.000"," 0","   ","  55.629","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    ","    "')
        f = StringIO.StringIO("\n".join(self.data))
        f.name = "results.csv"

        url = "/garage/event/%d/results"%self.e.id

        post_data = {'name': 'AM', 'results_file': f}

        response = c.post(url, post_data)

        return response
    
    def test_upload_with_error1(self): 
        """make sure things work if the first result line is an error"""
        RaceClass.objects.all().delete()
        Session.objects.all().delete()

        response = self.base_upload_results()

        self.assertEqual(json.loads(response.content), 
                         {'results_file': 'Your results for CHRIS BRUBAKER included an unknown race class: STS'})

        runs = Run.objects.all()
        self.assertEqual(len(runs), 0)

        results = Result.objects.all()
        self.assertEqual(len(results), 0)

        sessions = Session.objects.all()
        self.assertEqual(len(sessions), 0)

    def test_upload_with_error2(self): 
        """make sure things work if the second result line is an error"""
        RaceClass.objects.exclude(abrv='STS').delete()
        Session.objects.all().delete()

        response = self.base_upload_results()

        self.assertEqual(json.loads(response.content),
                         {u'result_file': u'Your Reults for CHRIS MCPHERSON included a unknown entry, R in the Class column'})

        runs = Run.objects.all()
        self.assertEqual(len(runs), 0)

        results = Result.objects.all()
        self.assertEqual(len(results), 0)

        sessions = Session.objects.all()
        self.assertEqual(len(sessions), 0)    

    def test_upload_clean(self): 
        Session.objects.all().delete()

        response = self.base_upload_results()

        self.assertEqual(response.status_code, 200)

        runs = Run.objects.all()
        self.assertEqual(len(runs), 17)

        results = Result.objects.all()
        self.assertEqual(len(results), 2)

        sessions = Session.objects.all()
        self.assertEqual(len(sessions), 1)