예제 #1
0
 def test_all(self):
     l1 = len(storage.all('State'))
     state = State(name="State test all")
     state.save()
     output = storage.all('State')
     self.assertEqual(len(output), l1 + 1)
     self.assertIn(state.id, output.keys())
예제 #2
0
 def test_view_one_state_wrong(self):
     """the id does not match a state"""
     state_args = {"name": "Zanzibar", "id": "ZA1"}
     state = State(**state_args)
     state.save()
     rv = self.app.get('{}/states/{}/'.format(self.path, "noID"))
     self.assertEqual(rv.status_code, 404)
     storage.delete(state)
예제 #3
0
 def test_count_state(self):
     """test count with an argument"""
     test_len = len(storage.all("State"))
     a = State(name="test_state_count_arg")
     a.save()
     self.assertEqual(test_len + 1, storage.count("State"))
     storage.delete(a)
     self.assertEqual(test_len, storage.count("State"))
예제 #4
0
 def test_save(self):
     test_len = len(storage.all())
     a = Amenity(name="another")
     a.save()
     self.assertEqual(len(storage.all()), test_len + 1)
     b = State(name="california")
     self.assertNotEqual(len(storage.all()), test_len + 2)
     b.save()
     self.assertEqual(len(storage.all()), test_len + 2)
예제 #5
0
 def test_update_state_bad_id(self):
     """test update with no matching id"""
     state_args = {"name": "Zanzibar", "id": "ZA6"}
     state = State(**state_args)
     state.save()
     rv = self.app.put('{}/states/{}/'.format(self.path, "noID"),
                       content_type="application/json",
                       data=json.dumps({"id": "Z"}),
                       follow_redirects=True)
     self.assertEqual(rv.status_code, 404)
     storage.delete(state)
예제 #6
0
 def test_count(self):
     """test count all"""
     test_len = len(storage.all())
     a = Amenity(name="test_amenity")
     a.save()
     self.assertEqual(test_len + 1, storage.count())
     b = State(name="State test count")
     b.save()
     self.assertEqual(test_len + 2, storage.count())
     storage.delete(b)
     self.assertEqual(test_len + 1, storage.count())
예제 #7
0
 def test_update_state_bad_json(self):
     """test update with ill formedt json"""
     state_args = {"name": "Zanzibar", "id": "ZA5"}
     state = State(**state_args)
     state.save()
     rv = self.app.put('{}/states/{}/'.format(self.path, state.id),
                       content_type="application/json",
                       data={"id": "Z"},
                       follow_redirects=True)
     self.assertEqual(rv.status_code, 400)
     self.assertEqual(rv.get_data(), b"Not a JSON")
     storage.delete(state)
예제 #8
0
 def test_view_one_state(self):
     """test retrieving one state"""
     state_args = {"name": "Zanzibar", "id": "ZA3"}
     state = State(**state_args)
     state.save()
     rv = self.app.get('{}/states/{}/'.format(self.path, state_args["id"]))
     self.assertEqual(rv.status_code, 200)
     self.assertEqual(rv.headers.get("Content-Type"), "application/json")
     json_format = getJson(rv)
     self.assertEqual(json_format.get("name"), state_args["name"])
     self.assertEqual(json_format.get("id"), state_args["id"])
     storage.delete(state)
예제 #9
0
 def test_getstates(self):
     """test listing all states"""
     state_args = {"name": "Zanzibar"}
     state = State(**state_args)
     state.save()
     rv = self.app.get('{}/states/'.format(self.path))
     self.assertEqual(rv.status_code, 200)
     self.assertEqual(rv.headers.get("Content-Type"), "application/json")
     json_format = getJson(rv)
     self.assertTrue(type(json_format), list)
     self.assertIn(state_args["name"], [e.get("name") for e in json_format])
     storage.delete(state)
예제 #10
0
 def test_delete_state(self):
     """test delete a state"""
     state_args = {"name": "Zanzibar", "id": "ZA"}
     state = State(**state_args)
     state.save()
     rv = self.app.delete('{}/states/{}/'.format(self.path,
                                                 state_args["id"]),
                          follow_redirects=True)
     self.assertEqual(rv.status_code, 200)
     self.assertEqual(rv.headers.get("Content-Type"), "application/json")
     json_format = getJson(rv)
     self.assertEqual(json_format, {})
     self.assertIsNone(storage.get("State", state_args["id"]))
예제 #11
0
 def test_update_state_id(self):
     """test cannot update state id"""
     state_args = {"name": "Zanzibar", "id": "ZA4"}
     state = State(**state_args)
     state.save()
     rv = self.app.put('{}/states/{}/'.format(self.path, state.id),
                       content_type="application/json",
                       data=json.dumps({"id": "Z"}),
                       follow_redirects=True)
     self.assertEqual(rv.status_code, 200)
     self.assertEqual(rv.headers.get("Content-Type"), "application/json")
     json_format = getJson(rv)
     self.assertEqual(json_format.get("name"), state_args["name"])
     self.assertEqual(json_format.get("id"), state_args["id"])
     storage.delete(state)
예제 #12
0
파일: base.py 프로젝트: sunu/oppia-test
    def test_editor(self, exploration_id, state_id=None, **kwargs):
        """Gets the user and exploration id if the user can edit it.

        Args:
            self: the handler instance
            exploration_id: the exploration id
            state_id: the state id, if it exists
            **kwargs: any other arguments passed to the handler

        Returns:
            The user and exploration instance, if the user is authorized to edit
            this exploration. Also, the state instance, if one is supplied.

        Raises:
            self.NotLoggedInException: if there is no current user.
            self.UnauthorizedUserException: if the user exists but does not have
                the right credentials.
        """
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))
            return

        exploration = Exploration.get(exploration_id)

        if not exploration.is_editable_by(user):
            raise self.UnauthorizedUserException(
                '%s does not have the credentials to edit this exploration.',
                user)

        if not state_id:
            return handler(self, user, exploration, **kwargs)
        state = State.get(state_id, exploration)
        return handler(self, user, exploration, state, **kwargs)
예제 #13
0
 def test_get_state(self):
     """test get with valid cls and id"""
     a = State(name="test_state3", id="test_3")
     a.save()
     result = storage.get("State", "test_3")
     self.assertEqual(a.name, result.name)
     # does not work as the database loses last argument tzinfo for datetime
     # self.assertEqual(a.created_at, result.created_at)
     self.assertEqual(a.created_at.year, result.created_at.year)
     self.assertEqual(a.created_at.month, result.created_at.month)
     self.assertEqual(a.created_at.day, result.created_at.day)
     self.assertEqual(a.created_at.hour, result.created_at.hour)
     self.assertEqual(a.created_at.minute, result.created_at.minute)
     self.assertEqual(a.created_at.second, result.created_at.second)
     storage.delete(a)
     result = storage.get("State", "test_3")
     self.assertIsNone(result)
예제 #14
0
    def test_terminal_functions(self):
        state = State.state_from_field(self.field)
        self.assertFalse(state.is_terminal())
        self.assertFalse(state.predators_have_collided())
        self.assertFalse(state.prey_is_caught())

        # Move prey to location of first predator
        self.field.get_prey().location = (0, 0)
        state = State.state_from_field(self.field)
        self.assertTrue(state.is_terminal())
        self.assertFalse(state.predators_have_collided())
        self.assertTrue(state.prey_is_caught())

        # Move predator 1 to location of last predator
        self.field.get_predators()[0].location = (10, 0)
        state = State.state_from_field(self.field)
        self.assertTrue(state.is_terminal())
        self.assertTrue(state.predators_have_collided())
        self.assertFalse(state.prey_is_caught())
예제 #15
0
 def test_predators_have_collided(self):
     f = Field(11, 11)
     predator1 = Predator(id="Plato", location=(1, 1))
     predator2 = Predator(id="Pythagoras", location=(1, 1))
     chip = Prey(id="Kant", location=(5, 5))
     f.add_player(predator1)
     f.add_player(predator2)
     f.add_player(chip)
     s = State.state_from_field(f)
     self.assertTrue(s.predators_have_collided())
     self.assertTrue(s.prey_is_caught() == False)
예제 #16
0
파일: field.py 프로젝트: tjbwyk/aa2-old
    def init_players(self):
        """
        After adding all the players to the field, this function will call the init_player function on all the players.
        :return:
        """
        self.players.sort(key=lambda player: player.id)

        for player in self.players:
            player.init_player()

        self.state = State.state_from_field(self)
        self.initialized = True
예제 #17
0
파일: field.py 프로젝트: tjbwyk/aa2-old
    def run_step(self):
        """
        Runs a step of the current episode by telling all agents to pick their respective next action based on the
        state of the field. Then, it computes the locations of all players in the next state and possible rewards.
        Finally, new state and reward is distributed to all players so they can learn from their action.
        :return:
        """
        assert(self.initialized is True)

        old_state = self.state
        actions = dict()
        rewards = dict()
        # for every player:
        for player in self.players:
            # call act() function on player and get desired action in return
            actions[player] = player.act(self.state)

        # compute next state based on actions chosen by players
        for pred in self.get_predators():
            pred.location = self.transition(pred, actions[pred])
        # if the prey has been caught, it cannot move anymore
        if not State.state_from_field(self).prey_is_caught():
            self.get_prey().location = self.transition(self.get_prey(), actions[self.get_prey()])

        # get new field state after every player moved
        new_state = State.state_from_field(self)

        # compute all rewards
        for player in self.players:
            rewards[player] = self.get_reward(new_state, player)

        # tell each player their new location and reward
        for player in self.players:
            player.update(old_state=old_state, new_state=new_state, actions=actions, rewards=rewards)

        self.steps += 1
        self.update_state()
        return
예제 #18
0
 def test_to_dict_id_str(self):
     """test type of 'id' value is a str"""
     s = State()
     s_dictionary = s.to_dict()
     self.assertEqual(str, type(s_dictionary['id']))
예제 #19
0
 def test_class_name(self):
     """test __class__ key in dictionary"""
     s = State()
     state_dictionary = s.to_dict()
     self.assertIn('__class__', state_dictionary)
예제 #20
0
 def test_created_and_updated_at_init(self):
     """created_at and updated_at attrs initialized
     to current datetime test"""
     s = State()
     self.assertEqual(s.created_at, s.updated_at)
예제 #21
0
 def test_id(self):
     """id attr test"""
     s = State()
     self.assertEqual(str, type(s.id))
예제 #22
0
 def test_state_type(self):
     """tests state instance is created"""
     s = State()
     self.assertEqual(type(State()), type(s))
예제 #23
0
 def test_all_states(self):
     all_states = State.all_states(self.field)
     self.assertEqual(len(all_states), 1771561)
예제 #24
0
 def test_save_method(self):
     """test save method"""
     dummy_instance = State()
     dummy_instance.save()
     self.assertNotEqual(dummy_instance.created_at,
                         dummy_instance.updated_at)
예제 #25
0
 def test_field_name(self):
     """ test first name field"""
     dummy_instance = State()
     self.assertEqual(self.state.name, "toor")
     self.assertIsInstance(self.state.name, str)
     self.assertEqual(dummy_instance.name, "")
예제 #26
0
 def setUp(cls):
     """steup class """
     cls.state = State()
     cls.state.name = "toor"
     cls.state.save()
예제 #27
0
 def setUpClass(cls):
     '''setting method to tests instance'''
     cls.insta = State()
예제 #28
0
    def test_uniq_id(self):
        """Tests unique user ids."""

        l = [State().id for i in range(1000)]
        self.assertEqual(len(set(l)), len(l))
예제 #29
0
 def test_state_from_field(self):
     state = State.state_from_field(self.field)
     self.assertEqual(state.relative_distances, [(5, 5), (5, -5), (-5, 5)])
예제 #30
0
 def test_new(self):
     """Test new method."""
     st = State(name="Washington")
     self.storage.new(st)
     store = list(self.storage._DBStorage__session.new)
     self.assertIn(st, store)
예제 #31
0
def run_wolf(n_episodes=1000):
    # initialize the environment
    field = Field(3, 3)

    """
    initial state:
    | | | |
    |X|O|X|
    | | | |
    """
    pred1loc = (0, 1)
    pred2loc = (2, 1)
    preyloc = (1, 1)

    predator1 = Predator(id="Plato", location=pred1loc)
    predator2 = Predator(id="Pythagoras", location=pred2loc)

    # WoLF
    predator1.plearner = Wolf_phc.create_greedy_plearner(field=field, agent=predator1)
    predator2.plearner = Wolf_phc.create_greedy_plearner(field=field, agent=predator2)
    field.add_player(predator1)
    field.add_player(predator2)

    chip = Prey(id="Kant", location=preyloc)
    chip.plearner = Wolf_phc.create_greedy_plearner(field=field, agent=chip, epsilon=0.01)
    field.add_player(chip)
    field.init_players()

    plot_state = State.state_from_field(field)

    num_steps = []
    pred_win = []
    value_of_pred1 = []
    value_of_pred2 = []
    value_of_prey = []

    for i in range(0, n_episodes):
        predator1.location = pred1loc
        predator2.location = pred2loc
        chip.location = preyloc
        field.update_state()
        field.steps = 0
        # run the simulation
        while not field.is_ended():
            field.run_step()

        num_steps.append(field.steps)
        pred_win.append(field.state.prey_is_caught())
        value_of_pred1.append(predator1.plearner.policy.get_probability_mapping(plot_state))
        value_of_pred2.append(predator2.plearner.policy.get_probability_mapping(plot_state))
        value_of_prey.append(chip.plearner.policy.get_probability_mapping(plot_state))

        # print progress every 10%
        if n_episodes > 10 and i % (n_episodes / 10) == 0:
            print int(1.0 * i / n_episodes * 100), "%"

    # some list wrangling to get a list of 5 action lists with values for each predator
    vp1 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred1)]
    vp2 = [[val[0] for val in sublist] for sublist in zip(*value_of_pred2)]
    vpc = [[val[0] for val in sublist] for sublist in zip(*value_of_prey)]


    # create plots
    colors = ["r", "b", "g", "k", "m"]
    actions = {
        (0, 0): "stay",
        (-1, 0): "left",
        (1, 0): "right",
        (0, -1): "up",
        (0, 1): "down"
    }
    plt.figure(figsize=(15, 15))

    s = plt.subplot(3, 1, 1)
    s.set_yscale("log")
    for index, action in enumerate(predator1.actions):
        plt.plot(vp1[index], c=colors[index], label=actions[action])
    plt.title("action probabilities for predator 1")
    plt.legend(loc="upper right")

    s = plt.subplot(3, 1, 2)
    s.set_yscale("log")
    for index, action in enumerate(predator2.actions):
        plt.plot(vp2[index], c=colors[index], label=actions[action])
    plt.title("action probabilities for predator 2")
    # plt.legend(loc="upper left")

    s = plt.subplot(3, 1, 3)
    s.set_yscale("log")
    for index, action in enumerate(chip.actions):
        plt.plot(vpc[index], c=colors[index], label=actions[action])
    plt.title("action probabilities for prey")

    plt.suptitle(str(n_episodes) + " episodes")
    plt.savefig(get_output_path() + "policychange-wolf-" + str(n_episodes) + ".pdf")
예제 #32
0
 def test_get_method(self):
     """Test get method for the API"""
     test = State(name="California")
     test.save()
     self.assertEqual(storage.get("State", test.id), test)
예제 #33
0
 def test_state(self):
     """test State creation with a keyword argument"""
     a = State(name="Kamchatka", id="Kamchatka666")
     a.save()
     self.assertIn("Kamchatka666", storage.all("State").keys())
예제 #34
0
 def test_count(self):
     """ Test again!! angel gulity"""
     counter = storage.count(State)
     test = State(name="California")
     test.save()
     self.assertEqual(storage.count(State), counter + 1)
예제 #35
0
 def test_dict_to_created_at_attr_type(self):
     """test dict -> instance's created_at attr type"""
     s = State()
     s_dictionary = s.to_dict()
     s2 = State(**s_dictionary)
     self.assertEqual(type(datetime.now()), type(s2.created_at))
예제 #36
0
 def setUp(self):
     """Set up which instance to call"""
     self._class = State()
     self._class2 = State()
     self._name = "State"
예제 #37
0
 def test_name_default(self):
     """tests default value of name attr"""
     s = State()
     self.assertEqual("", s.name)
예제 #38
0
    def test_State_inheritence(self):
        '''Test that State class inherits from BaseModel.'''

        new_state = State()
        self.assertIsInstance(new_state, BaseModel)
예제 #39
0
 def test_updated_at(self):
     """created_at attr test"""
     s = State()
     self.assertEqual(datetime, type(s.updated_at))
예제 #40
0
파일: reader.py 프로젝트: sunu/oppia-test
    def post(self, exploration_id, state_id):
        """Handles feedback interactions with readers."""
        values = {'error': []}

        exploration = Exploration.get(exploration_id)
        state = State.get(state_id, exploration)
        old_state = state

        payload = json.loads(self.request.get('payload'))

        # The 0-based index of the last content block already on the page.
        block_number = payload.get('block_number')
        params = self.get_params(state, payload.get('params'))
        # The reader's answer.
        answer = payload.get('answer')

        # Add the reader's answer to the parameter list. This must happen before
        # the interactive widget is constructed.
        params['answer'] = answer

        interactive_widget_properties = (
            InteractiveWidget.get_with_params(
                state.widget.widget_id)['actions']['submit'])

        dest_id, feedback, rule, recorded_answer = state.transition(
            answer, params, interactive_widget_properties)

        if recorded_answer:
            EventHandler.record_rule_hit(
                exploration_id, state_id, rule, recorded_answer)
            # Add this answer to the state's 'unresolved answers' list.
            if recorded_answer not in old_state.unresolved_answers:
                old_state.unresolved_answers[recorded_answer] = 0
            old_state.unresolved_answers[recorded_answer] += 1
            # TODO(sll): Make this async?
            old_state.put()

        assert dest_id

        html_output, widget_output = '', []
        # TODO(sll): The following is a special-case for multiple choice input,
        # in which the choice text must be displayed instead of the choice
        # number. We might need to find a way to do this more generically.
        if state.widget.widget_id == 'MultipleChoiceInput':
            answer = state.widget.params['choices'][int(answer)]

        # Append reader's answer.
        values['reader_html'] = feconf.JINJA_ENV.get_template(
            'reader_response.html').render({'response': answer})

        if dest_id == feconf.END_DEST:
            # This leads to a FINISHED state.
            if feedback:
                html_output, widget_output = self.append_feedback(
                    feedback, html_output, widget_output, block_number, params)
            EventHandler.record_exploration_completed(exploration_id)
        else:
            state = State.get(dest_id, exploration)
            EventHandler.record_state_hit(exploration_id, state_id)

            if feedback:
                html_output, widget_output = self.append_feedback(
                    feedback, html_output, widget_output, block_number, params)

            # Append text for the new state only if the new and old states
            # differ.
            if old_state.id != state.id:
                state_html, state_widgets = parse_content_into_html(
                    state.content, block_number, params)
                # Separate text for the new state and feedback for the old state
                # by an additional line.
                if state_html and feedback:
                    html_output += '<br>'
                html_output += state_html
                widget_output.append(state_widgets)

        if state.widget.widget_id in DEFAULT_ANSWERS:
            values['default_answer'] = DEFAULT_ANSWERS[state.widget.widget_id]
        values['exploration_id'] = exploration.id
        values['state_id'] = state.id
        values['oppia_html'] = html_output
        values['widgets'] = widget_output
        values['block_number'] = block_number + 1
        values['params'] = params

        if dest_id != feconf.END_DEST:
            values['finished'] = False
            if state.widget.sticky and (
                    state.widget.widget_id == old_state.widget.widget_id):
                values['interactive_widget_html'] = ''
                values['sticky_interactive_widget'] = True
            else:
                values['interactive_widget_html'] = (
                    InteractiveWidget.get_raw_code(
                        state.widget.widget_id,
                        params=utils.parse_dict_with_params(
                            state.widget.params, params)
                    )
                )
        else:
            values['finished'] = True
            values['interactive_widget_html'] = ''

        self.response.write(json.dumps(values))
예제 #41
0
 def test_save_updated_at(self):
     """save method changing updated_at attr to current datetime test"""
     s = State()
     prev_updated_at = s.updated_at
     s.save()
     self.assertNotEqual(prev_updated_at, s.updated_at)
예제 #42
0
파일: field.py 프로젝트: tjbwyk/aa2-old
 def update_state(self):
     """
     workaround until above todo is fixed
     :return:
     """
     self.state = State.state_from_field(self)
예제 #43
0
 def test_class_name_user(self):
     """test __class__ key in dictionary value is State"""
     s = State()
     state_dictionary = s.to_dict()
     self.assertEqual('State', state_dictionary['__class__'])
예제 #44
0
 def test_heritage(self):
     """ check it is a subclass of BaseModel
     """
     my_class = State()
     self.assertTrue(issubclass(type(my_class), BaseModel))
예제 #45
0
 def test_to_dict_updated_at(self):
     """test 'updated_at' is in dictionary returned by to_dict method"""
     s = State()
     s_dictionary = s.to_dict()
     self.assertIn('updated_at', s_dictionary)
 def setUpClass(cls):
     """set up for test"""
     cls.state = State()
     cls.state.name = "CA"
예제 #47
0
 def test_name(self):
     """test for name"""
     e = State()
     e.name = "abc"
     self.assertEqual(type(State.name), str)
예제 #48
0
 def test_to_dict_created_at_str(self):
     """test type of 'created_at' value is a str"""
     s = State()
     s_dictionary = s.to_dict()
     self.assertEqual(str, type(s_dictionary['created_at']))
예제 #49
0
파일: editor.py 프로젝트: sunu/oppia-test
    def put(self, unused_user, exploration, state):
        """Saves updates to a state."""

        payload = json.loads(self.request.get('payload'))

        yaml_file = payload.get('yaml_file')
        if yaml_file and feconf.ALLOW_YAML_FILE_UPLOAD:
            # The user has uploaded a YAML file. Process only this action.
            state = State.modify_using_dict(
                exploration, state,
                utils.dict_from_yaml(yaml_file))
            self.response.write(json.dumps(
                get_state_for_frontend(state, exploration)))
            return

        state_name = payload.get('state_name')
        param_changes = payload.get('param_changes')
        interactive_widget = payload.get('interactive_widget')
        interactive_params = payload.get('interactive_params')
        interactive_rulesets = payload.get('interactive_rulesets')
        sticky_interactive_widget = payload.get('sticky_interactive_widget')
        content = payload.get('content')
        unresolved_answers = payload.get('unresolved_answers')

        if 'state_name' in payload:
            # Replace the state name with this one, after checking validity.
            if state_name == feconf.END_DEST:
                raise self.InvalidInputException('Invalid state name: END')
            exploration.rename_state(state, state_name)

        if 'param_changes' in payload:
            state.param_changes = [
                ParamChange(
                    name=param_change['name'], values=param_change['values'],
                    obj_type='UnicodeString'
                ) for param_change in param_changes
            ]

        if interactive_widget:
            state.widget.widget_id = interactive_widget

        if interactive_params:
            state.widget.params = interactive_params

        if sticky_interactive_widget is not None:
            state.widget.sticky = sticky_interactive_widget

        if interactive_rulesets:
            ruleset = interactive_rulesets['submit']
            utils.recursively_remove_key(ruleset, u'$$hashKey')

            state.widget.handlers = [AnswerHandlerInstance(
                name='submit', rules=[])]

            # This is part of the state. The rules should be put into it.
            state_ruleset = state.widget.handlers[0].rules

            # TODO(yanamal): Do additional calculations here to get the
            # parameter changes, if necessary.
            for rule_ind in range(len(ruleset)):
                rule = ruleset[rule_ind]

                state_rule = Rule()
                if 'attrs' in rule and 'classifier' in rule['attrs']:
                    state_rule.name = rule['attrs']['classifier']
                state_rule.inputs = rule.get('inputs')
                state_rule.dest = rule.get('dest')
                state_rule.feedback = rule.get('feedback')

                # Generate the code to be executed.
                if rule['rule'] == 'Default':
                    # This is the default rule.
                    assert rule_ind == len(ruleset) - 1
                    state_rule.name = 'Default'
                    state_ruleset.append(state_rule)
                    continue

                # Normalize the params here, then store them.
                classifier_func = state_rule.name.replace(' ', '')
                first_bracket = classifier_func.find('(')
                mutable_rule = rule['rule']

                params = classifier_func[first_bracket + 1: -1].split(',')
                for index, param in enumerate(params):
                    if param not in rule['inputs']:
                        raise self.InvalidInputException(
                            'Parameter %s could not be replaced.' % param)

                    typed_object = state.get_typed_object(mutable_rule, param)
                    # TODO(sll): Make the following check more robust.
                    if (not isinstance(rule['inputs'][param], basestring) or
                            '{{' not in rule['inputs'][param] or
                            '}}' not in rule['inputs'][param]):
                        normalized_param = typed_object.normalize(
                            rule['inputs'][param])
                    else:
                        normalized_param = rule['inputs'][param]

                    if normalized_param is None:
                        raise self.InvalidInputException(
                            '%s has the wrong type. Please replace it with a '
                            '%s.' % (rule['inputs'][param],
                                     typed_object.__name__))

                    state_rule.inputs[param] = normalized_param

                state_ruleset.append(state_rule)

        if content:
            state.content = [Content(type=item['type'], value=item['value'])
                             for item in content]

        if 'unresolved_answers' in payload:
            state.unresolved_answers = {}
            for answer, count in unresolved_answers.iteritems():
                if count > 0:
                    state.unresolved_answers[answer] = count

        state.put()
        self.response.write(json.dumps(
            get_state_for_frontend(state, exploration)))
예제 #50
0
 def test_dict_to_instance(self):
     """test dict -> instance"""
     s = State()
     s_dictionary = s.to_dict()
     s2 = State(**s_dictionary)
     self.assertEqual(type(s), type(s2))
예제 #51
0
 def test_dict_to_id_attr_type(self):
     """test dict -> instance's id attr"""
     s = State()
     s_dictionary = s.to_dict()
     s2 = State(**s_dictionary)
     self.assertEqual(str, type(s2.id))
예제 #52
0
 def test_dict_to_created_at_attr(self):
     """test dict -> instance's created_at attr"""
     s = State()
     s_dictionary = s.to_dict()
     s2 = State(**s_dictionary)
     self.assertEqual(s.created_at, s2.created_at)
예제 #53
0
    def test_State_attributes(self):
        '''Test that State class contains the attribute `name`.'''

        new_state = State()
        self.assertTrue("name" in new_state.__dir__())
예제 #54
0
 def test_all_states_without_terminal(self):
     states = State.all_states_without_terminal(self.field)
     self.assertEqual(len(states), 1685040)
예제 #55
0
 def test_State_attributes(self):
     '''
         Test that State class contains the attribute `name`.
     '''
     new_state = State()
     self.assertTrue("name" in new_state.__dir__())
예제 #56
0
    def test_State_attributes_type(self):
        '''Test that State class attribute name is class type str.'''

        new_state = State()
        name = getattr(new_state, "name")
        self.assertIsInstance(name, str)