コード例 #1
0
ファイル: categorizer_test.py プロジェクト: HScarb/rankedftw
 def test_exception_if_ap_and_strange_points(self):
     al = gen_api_ladder(members=[
         gen_member(points=1.1, join_time=self.datetime(days=-7)),
     ],
                         gd=False)
     with self.assertRaises(Exception):
         get_strangeness(self.datetime(), al, ap=1)
コード例 #2
0
ファイル: categorizer_test.py プロジェクト: HScarb/rankedftw
 def test_categorize_as_nop_if_ceritain_time_good_points_and_no_ap(self):
     al = gen_api_ladder(members=[
         gen_member(points=1, join_time=self.datetime(days=-20)),
     ],
                         gd=False)
     self.assertEqual(Ladder.NOP,
                      get_strangeness(self.datetime(), al, ap=None))
コード例 #3
0
ファイル: categorizer_test.py プロジェクト: HScarb/rankedftw
 def test_categorize_as_genuine_strange_imediatly(self):
     al = gen_api_ladder(members=[
         gen_member(points=1.2, join_time=self.s16_time),
     ],
                         gd=False)
     self.assertEqual(Ladder.STRANGE,
                      get_strangeness(self.datetime(), al, ap=None))
コード例 #4
0
ファイル: categorizer_test.py プロジェクト: HScarb/rankedftw
 def test_what_happens_if_low_member_count_and_random_strange_but_even_(
         self):
     al = gen_api_ladder(members=[
         gen_member(points=1, join_time=self.datetime(days=-20)),
     ],
                         gd=False)
     self.assertEqual(Ladder.NOP,
                      get_strangeness(self.datetime(), al, ap=None))
コード例 #5
0
ファイル: categorizer_test.py プロジェクト: HScarb/rankedftw
 def test_categorize_as_good_if_ap(self):
     al = gen_api_ladder(members=[
         gen_member(points=1, join_time=self.datetime(days=-7)),
     ],
                         gd=False)
     self.assertEqual(Ladder.GOOD, get_strangeness(self.datetime(),
                                                   al,
                                                   ap=1))
    def run(self, args, logger):
        seasons = list(Season.objects.filter(pk__gte=args.ss_id, pk__lte=args.es_id))

        for region in args.regions:
            logger.info("processing region %s" % region)

            for ladder in Ladder.objects.filter(season__in=seasons, region=region, bid__gte=args.bid).order_by('bid'):

                self.check_stop()

                context = "ladder %d, region %s, bid %d, %s" %\
                          (ladder.id, Region.key_by_ids[region], ladder.bid, ladder.info())

                try:
                    lcs = ladder.cached_raw.filter(type=Cache.LADDER).order_by('id')
                    if len(lcs) != 1:
                        raise Exception("expected one ladder cache for ladder %d, found %s" %
                                        (ladder.id, [c.id for c in lcs]))
                    lc = lcs[0]
                    if lc.bid != ladder.bid or lc.region != ladder.region:
                        raise Exception("bid or region did not match lc on %s" % ladder.id)

                    al = ApiLadder(loads(lc.data), lc.url)

                    pcs = ladder.cached_raw.filter(type=Cache.PLAYER_LADDERS)
                    if len(pcs) > 1:
                        raise Exception("expected one player ladders cache for ladder %d, found %s" %
                                        (ladder.id, [c.id for c in pcs]))
                    pc = pcs[0] if pcs else None
                    if pc:
                        if pc.region != ladder.region:
                            raise Exception("region did not match pc on %s, %s" % ladder.id)
                        ap = ApiPlayerLadders(loads(pc.data), pc.url)
                    else:
                        ap = None

                    new = Ladder()

                    join_season, join_valid = get_season_based_on_join_times(al.first_join(), al.last_join())
                    if ap:
                        match = ap.refers(ladder.bid)
                        if not match:
                            logger.error("%s: failed match" % context)
                            continue

                        context += ", match %s" % match

                        new.season, valid = determine_season(fetch_time=lc.updated, match=match,
                                                             join_season=join_season, join_valid=join_valid)
                    else:
                        new.season, valid = join_season, join_valid
                        context += ", match None"

                    new.version, new.mode, new.league = get_version_mode_league(ladder.bid, new.season, al, ap)

                    new.strangeness = get_strangeness(lc.updated, al, ap)

                    for what in args.verify.split(','):
                        nv = getattr(new, what)
                        ov = getattr(ladder, what)
                        if nv != ov:
                            if new.strangeness in (Ladder.GOOD, Ladder.NOP):
                                log = logger.error
                            else:
                                log = logger.warning
                            log("%s: failed %s, old %s, new %s" % (context, what, ov, nv))
                            break
                    else:
                        logger.info("%s: success" % context)

                except Exception as e:
                    logger.error("%s: %s(\"%s\")" % (context, e.__class__.__name__, e))

        return 0