Python models.Challenge类代码示例

 def test_challenge_index(self):
     Challenge.create(user_from=self.ch_player2, user_to=self.ch_player1,
                     ignore_questions=True)
     response = self.c.get(reverse('challenge_index_view'))
     # Test if both challenges are displayed
     self.assertContains(response, 'testuser1</a> vs')
     self.assertContains(response, 'testuser2</a> vs')

    def test_weakness(self):
        """
         Test for weakness
        """

        initial_points = 10

        player = self._get_player()
        player2 = self._get_player(2)
        chall_user = player.get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(chall_user, 'points', initial_points)
        self.assertEqual(player.points, initial_points)

        # Points won before Weakness is applied
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)
        points_no_weakness = player.points

        # Applying Weakness
        weakness = Spell.objects.create(name='challenge-affect-scoring', available=True, price=10, percents=-66, type='n')
        obs = PlayerSpellDue.objects.create(player=chall_user, source=chall_user, spell=weakness, due=datetime.now() + timedelta(days=1))
        self.assertTrue(chall_user.magic.has_modifier('challenge-affect-scoring'))

        player.points = initial_points
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)

        # Player should win 66% less points with weakness applied
        self.assertEqual(player.points, points_no_weakness - 0.66 * (points_no_weakness - initial_points))

    def test_charge(self):
        """
         Test for Charge spell
        """
        initial_points = 10

        player = self._get_player()
        player2 = self._get_player(2)
        chall_user = player.get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(chall_user, 'points', initial_points)
        self.assertEqual(player.points, initial_points)

        # Points won before Charge is applied
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)
        points_no_charge = player.points

        # Apply Charge
        charge = Spell.objects.create(name='challenge-affect-scoring', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=chall_user, source=chall_user, spell=charge, due=datetime.now() + timedelta(days=1))
        self.assertTrue(chall_user.magic.has_modifier('challenge-affect-scoring'))

        player.points = initial_points
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)

        # Player should have 33% more points with charge applied
        self.assertEqual(player.points, points_no_charge + 0.33 * (points_no_charge - initial_points))

    def testLaunch(self):
        chall = Challenge.create(user_from=self.chall_user, user_to=self.chall_user2, ignore_questions=True)

        self.assertTrue(isinstance(chall, Challenge))
        self.assertTrue(chall.is_launched())

        chall.refuse()
        self.assertTrue(chall.is_refused())
        chall.delete()

        chall = Challenge.create(user_from=self.chall_user, user_to=self.chall_user2, ignore_questions=True)
        chall.accept()
        self.assertTrue(chall.is_runnable())
        self.assertFalse(chall.is_refused())
        chall.delete()

    def test_charge(self):
        """
         Test for Charge spell
        """
        initial_points = 100
        win_points = 10

        player_charge = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player_charge, 'points', initial_points)

        formula = Formula.get('chall-won')
        formula.expression = 'points=' + str(win_points)
        formula.save()

        # Apply charge
        charge = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=player_charge, source=player_charge, spell=charge, due=datetime.now() + timedelta(days=1))

        chall = Challenge.create(user_from=player_charge, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player_charge)

        # Player should win weakness.percents more points with charge applied
        target_points = initial_points + win_points + charge.percents / 100.0 * win_points
        self.assertEqual(player_charge.player_ptr.points, target_points)

    def setUp(self):
        super(TestChallengeViews, self).setUp()
        self.ch_player1 = self._get_player(1)
        self.ch_player2 = self._get_player(2)
        race = Race.objects.create(name=u'testrace', can_play=True)
        self.ch_player1.race = race
        self.ch_player2.race = race
        self.ch_player1.points = 100
        self.ch_player2.points = 100
        self.ch_player1.save()
        self.ch_player2.save()
        self.ch_player1 = self.ch_player1.get_extension(ChallengeUser)
        self.ch_player2 = self.ch_player2.get_extension(ChallengeUser)
        scoring.setup_scoring()

        self.category = Category.add('challenge')
        self.question1 = Question.objects.create(text='question1', answer_type='F',
                                                 category=self.category, active=True)
        self.answer1 = Answer.objects.create(text='first answer', correct=True,
                                             question=self.question1)
        self.question2 = Question.objects.create(text='question2', answer_type='F',
                                                 category=self.category, active=True)
        self.answer2 = Answer.objects.create(text='second answer', correct=True,
                                             question=self.question2)
        self.ch = Challenge.create(user_from=self.ch_player1, user_to=self.ch_player2,
                        ignore_questions=True)
        self.ch.questions.add(self.question1)
        self.ch.questions.add(self.question2)

        self.c = Client()
        self.c.login(username='testuser1', password='test')

 def setUp(self):
     user_from = self._get_player(1)
     user_to = self._get_player(2)
     chall_user1 = user_from.get_extension(ChallengeUser)
     chall_user2 = user_to.get_extension(ChallengeUser)
     scoring.setup_scoring()
     self.chall = Challenge.create(user_from=chall_user1, user_to=chall_user2, ignore_questions=True)

    def test_weakness_and_charge(self):
        """
         If both Weakness and Charge are active, a player should win weakness.percents + charge.percents less/more points
         after winning a challenge
        """
        initial_points = 100
        win_points = 10

        player = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player, 'points', initial_points)

        formula = Formula.get('chall-won')
        formula.expression = 'points=' + str(win_points)
        formula.save()

        # Apply charge
        charge = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=player, source=player, spell=charge, due=datetime.now() + timedelta(days=1))

        # Apply weakness
        weakness = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=-66, type='p')
        obs = PlayerSpellDue.objects.create(player=player, source=player, spell=weakness, due=datetime.now() + timedelta(days=1))

        chall = Challenge.create(user_from=player, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player)

        percents = (charge.percents + weakness.percents) / 100.0
        target_points = initial_points + win_points + percents * win_points

        self.assertEqual(player.player_ptr.points, target_points)

    def test_post_challenge(self):
        # create an active challenge, with fake questions
        Formula.objects.create(id='chall-warranty')
        category = Category.objects.create(name='challenge')
        for i in range(5):
            q = Question.objects.create(text='text %s' % i, category=category, active=True)
            for j in range(5):
                Answer.objects.create(correct=j==1, question=q)
        chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser)
        chall.accept()
        response = self.client.get('/api/challenge/{id}/'.format(id=chall.id))
        data = json.loads(response.content)

        self.assertTrue(data)
        self.assertEqual(data['status'], 'A')
        self.assertEqual(data['to'], self.challuser.user.username)
        self.assertEqual(len(data['questions']), 5)

        # attempt post
        data = {}
        for q in Question.objects.all():
            answers = []
            for a in q.correct_answers:
                answers.append(str(a.id))

            data[q.id] = ','.join(answers)

        response = self.client.post('/api/challenge/{id}/'.format(id=chall.id), data)
        self.assertEqual(response.status_code, 200)

        data = json.loads(response.content)

        self.assertTrue(data['success'])
        self.assertEqual(data['result']['points'], 500)

    def test_run_is_started(self):
        chall = Challenge.create(user_from=self.chall_user, user_to=self.chall_user2, ignore_questions=True)

        chall.accept()
        chall.set_start(self.chall_user)
        self.assertTrue(chall.is_started_for_user(self.chall_user))
        self.assertFalse(chall.is_started_for_user(self.chall_user2))

    def test_frenzy_loss(self):
        """
         If user loses while affected by frenzy he should lose frenzy.percents more points
        """
        initial_points = 100
        loss_points = -10
        warranty_points = -3

        player_frenzy = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player_frenzy, 'points', initial_points)

        formula = Formula.get('chall-lost')
        formula.expression = 'points=' + str(loss_points)
        formula.save()

        formula = Formula.get('chall-warranty')
        formula.expression = 'points=' + str(warranty_points)
        formula.save()

        # Apply frenzy
        frenzy = Spell.objects.create(name='challenge-affect-scoring', available=True, price=25, percents=66, type='o')
        obs = PlayerSpellDue.objects.create(player=player_frenzy, source=player_frenzy, spell=frenzy, due=datetime.now() + timedelta(days=1))

        # Win challenge with dummy player to see the amount of points lost by the player affected with frenzy
        chall = Challenge.create(user_from=player_frenzy, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player_dummy)

        # Player should lose frenzy.percents more points with frenzy applied
        target_points = initial_points + loss_points + frenzy.percents / 100.0 * loss_points + warranty_points

        self.assertEqual(player_frenzy.player_ptr.points, target_points)

 def setUp(self):
     super(FlawlessVictoryTest, self).setUp()
     self.user_from = self._get_player(1)
     self.user_to   = self._get_player(2)
     self.chall_user1 = self.user_from.get_extension(ChallengeUser)
     self.chall_user2 = self.user_to.get_extension(ChallengeUser)
     scoring.setup_scoring()
     self.chall = Challenge.create(user_from=self.chall_user1, user_to=self.chall_user2, ignore_questions=True)

    def test_custom_create(self):
        Challenge.WARRANTY = False
        game = ChallengeGame.get_instance()
        p1, p2 = self._get_player(1), self._get_player(2)

        challenge = Challenge.create_custom(p1, p2, [], game)
        self.assertTrue(challenge)
        self.assertEqual(challenge.owner, game)

 def create(cls, user_from, user_to, round):
     """ Create a new Challenge and automatically accept it.
     """
     grand_challenge = cls.objects.create(round=round)
     user_from = user_from.user.get_profile()
     user_to = user_to.user.get_profile()
     grand_challenge.challenge = Challenge.create(user_from.get_extension(ChallengeUser), user_to.get_extension(ChallengeUser))
     grand_challenge.challenge.accept()
     grand_challenge.save()
     return grand_challenge

    def test_custom_create(self):
        game = ChallengeGame.get_instance()
        p1, p2 = self._get_player(1), self._get_player(2)

        challenge = Challenge.create_custom(p1, p2, [], game)
        self.assertTrue(challenge)
        self.assertEqual(challenge.owner, game)


# TODO: add page tests (views) for challenge run