Python helpers.get_word_post_data函数代码示例

    def test_has_meaning__duplicate(self):
        self.assertEqual(Building.objects.all().count(), 0)

        VotePrototype.create(self.account2, self.bill, False)
        VotePrototype.create(self.account3, self.bill, True)

        noun = names.generator.get_test_name('building-name')
        data = linguistics_helpers.get_word_post_data(noun, prefix='name')
        data.update({'approved': True})

        form = BuildingCreate.ModeratorForm(data)

        self.assertTrue(form.is_valid())
        self.bill.update_by_moderator(form)
        self.assertTrue(self.bill.apply())

        dup_noun = names.generator.get_test_name('dup-building-name')
        data = linguistics_helpers.get_word_post_data(dup_noun, prefix='name')
        data.update({'approved': True})

        form = BuildingCreate.ModeratorForm(data)

        bill = BillPrototype.get_by_id(self.bill.id)
        bill.state = BILL_STATE.VOTING
        bill.save()

        self.assertTrue(form.is_valid())
        bill.update_by_moderator(form)

        self.assertFalse(bill.has_meaning())

    def test_apply(self):
        self.assertEqual(Building.objects.all().count(), 0)

        VotePrototype.create(self.account2, self.bill, False)
        VotePrototype.create(self.account3, self.bill, True)

        noun = names.generator.get_test_name('r-building-name')

        data = linguistics_helpers.get_word_post_data(noun, prefix='name')
        data.update({'approved': True})

        form = BuildingCreate.ModeratorForm(data)

        self.assertTrue(form.is_valid())
        self.bill.update_by_moderator(form)

        self.assertTrue(self.bill.apply())

        bill = BillPrototype.get_by_id(self.bill.id)
        self.assertTrue(bill.state.is_ACCEPTED)

        self.assertEqual(Building.objects.all().count(), 1)

        building = buildings_storage.all()[0]

        self.assertEqual(building.person.id, self.person_1.id)
        self.assertEqual(building.place.id, self.place1.id)
        self.assertEqual(building.utg_name, noun)

    def setUp(self):
        super(BillPlaceRenamingTests, self).setUp()

        bill_data = bills.PlaceRenaming(place_id=self.place1.id, name_forms=names.generator.get_test_name('new-name'))
        self.bill = BillPrototype.create(self.account1, 'bill-caption', 'bill-rationale', bill_data, chronicle_on_accepted='chronicle-on-accepted')

        data = linguistics_helpers.get_word_post_data(bill_data.name_forms, prefix='name')
        data.update({'approved': True})
        self.form = bills.PlaceRenaming.ModeratorForm(data)
        self.assertTrue(self.form.is_valid())

 def post_data(self):
     data = {'description': 'new-description',
             'type': relations.TYPE.random(),
             'max_health': 650,
             'dedication': relations.DEDICATION.random(),
             'archetype': game_relations.ARCHETYPE.random(),
             'mode': relations.MODE.random()}
     data.update(linguistics_helpers.get_word_post_data(names.generator.get_test_name(name='new_name'), prefix='name'))
     data.update(helpers.get_abilities_post_data(helpers.FAKE_ABILITIES_CONTAINER_2),)
     return data

    def test_create__with_parent__full_copy(self):
        for word_type in utg_relations.WORD_TYPE.records:
            word = utg_words.Word.create_test_word(word_type)

            parent = prototypes.WordPrototype.create(word)
            parent.state = relations.WORD_STATE.IN_GAME
            parent.save()

            requested_url = url('linguistics:words:create', type=word_type.value, parent=parent.id)

            with self.check_not_changed(prototypes.WordPrototype._db_count):
                self.check_ajax_error(self.client.post(requested_url, helpers.get_word_post_data(parent.utg_word)),
                                      'linguistics.words.create.full_copy_restricted')

    def test_create__parent_not_cpecified(self):
        for word_type in utg_relations.WORD_TYPE.records:
            word = utg_words.Word.create_test_word(word_type)

            parent = prototypes.WordPrototype.create(word)
            parent.state = random.choice(relations.WORD_STATE.records)
            parent.save()

            requested_url = url('linguistics:words:create', type=word_type.value)

            with self.check_delta(prototypes.WordPrototype._db_count, 0):
                self.check_ajax_error(self.client.post(requested_url, helpers.get_word_post_data(word)),
                                      'linguistics.words.create.parent_exists')

    def test_create_with_all_fields(self):
        for word_type in utg_relations.WORD_TYPE.records:
            word = utg_words.Word.create_test_word(word_type, prefix='w-')
            requested_url = url('linguistics:words:create', type=word_type.value)

            with self.check_delta(prototypes.WordPrototype._db_count, 1):
                response = self.client.post(requested_url, helpers.get_word_post_data(word))

            last_prototype = prototypes.WordPrototype._db_latest()

            self.check_ajax_ok(response, data={'next_url': url('linguistics:words:show', last_prototype.id)})

            self.assertEqual(word, last_prototype.utg_word)

 def post_data(self):
     data = {'description': 'new-description',
             'type': game_relations.BEING_TYPE.random(),
             'max_health': 650,
             'dedication': relations.DEDICATION.random(),
             'archetype': game_relations.ARCHETYPE.random(),
             'mode': relations.MODE.random(),
             'communication_verbal': game_relations.COMMUNICATION_VERBAL.CAN,
             'communication_gestures': game_relations.COMMUNICATION_GESTURES.CAN,
             'communication_telepathic': game_relations.COMMUNICATION_TELEPATHIC.CAN,
             'intellect_level': game_relations.INTELLECT_LEVEL.NORMAL}
     data.update(linguistics_helpers.get_word_post_data(names.generator.get_test_name(name='new_name'), prefix='name'))
     data.update(helpers.get_abilities_post_data(helpers.FAKE_ABILITIES_CONTAINER_2),)
     return data

    def get_create_data(self):
        word = names.generator.get_test_name(name='mob name')

        data = linguistics_helpers.get_word_post_data(word, prefix='name')

        data.update( { 'level': 666,
                'terrains': [TERRAIN.PLANE_GRASS, TERRAIN.HILLS_GRASS],
                'abilities': ['hit', 'strong_hit', 'sidestep'],
                'type': MOB_TYPE.CIVILIZED,
                'archetype': game_relations.ARCHETYPE.NEUTRAL,
                'global_action_probability': 0.5,
                'description': 'mob description'} )

        return data

    def test_has_meaning__duplicate_name(self):
        VotePrototype.create(self.account2, self.bill, False)
        VotePrototype.create(self.account3, self.bill, True)

        new_name = names.generator.get_test_name('new-new-name')
        self.bill.data.place.set_utg_name(new_name)

        data = linguistics_helpers.get_word_post_data(new_name, prefix='name')
        data.update({'approved': True})
        form = PlaceRenaming.ModeratorForm(data)
        self.assertTrue(form.is_valid())
        self.bill.update_by_moderator(form)

        self.assertFalse(self.bill.has_meaning())

    def get_update_data(self):
        word = names.generator.get_test_name(name='new name')

        data = linguistics_helpers.get_word_post_data(word, prefix='name')

        data.update( {'level': 667,
                'terrains': [TERRAIN.PLANE_JUNGLE, TERRAIN.HILLS_JUNGLE],
                'abilities': ['hit', 'speedup'],
                'type': MOB_TYPE.BARBARIAN,
                'archetype': game_relations.ARCHETYPE.MAGICAL,
                'global_action_probability': 0.1,
                'description': 'new description'})

        return data

    def get_form_data(self):
        mob = prototypes.MobRecordPrototype.create_random(uuid='bandit', state=relations.MOB_RECORD_STATE.DISABLED)

        data = linguistics_helpers.get_word_post_data(mob.utg_name, prefix='name')

        data.update( { 'level': str(mob.level),
                       'global_action_probability': '0.25',
                       'terrains': ['TERRAIN.PLANE_GRASS', 'TERRAIN.HILLS_GRASS'],
                       'abilities': ['hit', 'strong_hit', 'sidestep'],
                       'type': 'MOB_TYPE.CIVILIZED',
                       'archetype': 'ARCHETYPE.NEUTRAL',
                       'description': mob.description} )

        return data

    def get_create_data(self, mob=None):
        word = names.generator.get_test_name(name='artifact')
        data = linguistics_helpers.get_word_post_data(word, prefix='name')

        data.update({
                'level': 1,
                'type': relations.ARTIFACT_TYPE.RING,
                'power_type': relations.ARTIFACT_POWER_TYPE.NEUTRAL,
                'rare_effect': relations.ARTIFACT_EFFECT.POISON,
                'epic_effect': relations.ARTIFACT_EFFECT.GREAT_PHYSICAL_DAMAGE,
                'special_effect': relations.ARTIFACT_EFFECT.NO_EFFECT,
                'description': 'artifact description',
                'mob':  u'' if mob is None else mob.id})

        return data

    def get_update_data(self, mob=None):
        word = names.generator.get_test_name(name='new name')
        data = linguistics_helpers.get_word_post_data(word, prefix='name')

        data.update({
                'level': 2,
                'type': relations.ARTIFACT_TYPE.AMULET,
                'power_type': relations.ARTIFACT_POWER_TYPE.MAGICAL,
                'rare_effect': relations.ARTIFACT_EFFECT.NO_EFFECT,
                'epic_effect': relations.ARTIFACT_EFFECT.POISON,
                'special_effect': relations.ARTIFACT_EFFECT.CHILD_GIFT,
                'description': 'new artifact description',
                'mob': u'' if mob is None else mob.id})

        return data

    def test_update(self):
        data = linguistics_helpers.get_word_post_data(names.generator.get_test_name('new-building-name'), prefix='name')
        data.update({'caption': 'new-caption',
                     'rationale': 'new-rationale',
                     'chronicle_on_accepted': 'chronicle-on-accepted',
                     'person': self.person_2.id })

        form = self.bill.data.get_user_form_update(post=data)
        self.assertTrue(form.is_valid())

        self.bill.update(form)

        self.bill = BillPrototype.get_by_id(self.bill.id)

        self.assertEqual(self.bill.data.person_id, self.person_2.id)
        self.assertEqual(self.bill.data.base_name, u'new-building-name-нс,ед,им')