Beispiel #1
0
    def test_parse_square_bracket(self):
        text = "[foo, bar]"
        parser = traits_listener.ListenerParser(text=text)
        listener_group = parser.listener

        # then
        common_traits = dict(
            metadata_name="",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
            next=None,
        )
        expected_items = [
            traits_listener.ListenerItem(
                name="foo",
                **common_traits,
            ),
            traits_listener.ListenerItem(
                name="bar",
                **common_traits,
            )
        ]
        self.assertEqual(len(listener_group.items), len(expected_items))
        for actual, expected in zip(listener_group.items, expected_items):
            self.assertEqual(actual, expected)
Beispiel #2
0
    def test_parse_question_mark_only(self):
        text = "?"
        with self.assertRaises(TraitError) as exception_context:
            traits_listener.ListenerParser(text=text)

        self.assertIn("Expected non-empty name",
                      str(exception_context.exception))
Beispiel #3
0
    def test_parse_comma_separated_text(self):
        text = "child1, child2, child3"
        parser = traits_listener.ListenerParser(text=text)

        listener_group = parser.listener

        common_traits = dict(
            metadata_name="",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
            next=None,
        )
        expected_items = [
            traits_listener.ListenerItem(
                name="child1",
                **common_traits,
            ),
            traits_listener.ListenerItem(
                name="child2",
                **common_traits,
            ),
            traits_listener.ListenerItem(
                name="child3",
                **common_traits,
            ),
        ]
        self.assertEqual(len(listener_group.items), len(expected_items))
        for actual, expected in zip(listener_group.items, expected_items):
            self.assertEqual(actual, expected)
Beispiel #4
0
    def test_listener_parser_trait_of_trait_of_trait_mixed(self):
        text = "parent.child1:child2"
        parser = traits_listener.ListenerParser(text=text)

        # then
        common_traits = dict(
            metadata_name="",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
        )
        expected_child2 = traits_listener.ListenerItem(name="child2",
                                                       notify=True,
                                                       next=None,
                                                       **common_traits)
        expected_child1 = traits_listener.ListenerItem(
            name="child1",
            notify=False,  # ':' indicates no notifications
            next=expected_child2,
            **common_traits)
        expected_parent = traits_listener.ListenerItem(name="parent",
                                                       notify=True,
                                                       next=expected_child1,
                                                       **common_traits)
        self.assertEqual(parser.listener, expected_parent)
Beispiel #5
0
    def test_parse_text_with_question_mark(self):
        text = "foo?.bar?"
        parser = traits_listener.ListenerParser(text=text)

        # parent
        listener = parser.listener
        self.assertEqual(listener.name, "foo?")

        # child
        listener = listener.next
        self.assertEqual(listener.name, "bar?")
Beispiel #6
0
    def test_listener_parser_single_string(self):
        text = "some_trait_name"
        parser = traits_listener.ListenerParser(text=text)

        expected = traits_listener.ListenerItem(
            name="some_trait_name",
            metadata_name="",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
            next=None,
        )
        self.assertEqual(parser.listener, expected)
Beispiel #7
0
    def test_parse_is_list_handler(self):
        text = "foo[]"
        parser = traits_listener.ListenerParser(text=text)

        expected = traits_listener.ListenerItem(
            name="foo",
            metadata_name="",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=True,  # the effect of '[]'
            type=traits_listener.ANY_LISTENER,
            next=None,
        )
        self.assertEqual(parser.listener, expected)
Beispiel #8
0
    def test_parse_nested_exclude_empty_metadata_name(self):
        text = "foo-"
        parser = traits_listener.ListenerParser(text=text)

        expected = traits_listener.ListenerItem(
            name="foo*",
            metadata_name="",
            metadata_defined=False,  # the effect of '-'
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
            next=None,
        )
        self.assertEqual(parser.listener, expected)
Beispiel #9
0
    def test_parse_text_with_metadata(self):
        text = "prefix+foo"
        parser = traits_listener.ListenerParser(text=text)

        expected = traits_listener.ListenerItem(
            name="prefix*",
            metadata_name="foo",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
            next=None,
        )
        self.assertEqual(parser.listener, expected)
Beispiel #10
0
    def test_parse_with_asterisk(self):
        text = "prefix*"
        parser = traits_listener.ListenerParser(text=text)

        actual = parser.listener
        expected = traits_listener.ListenerItem(
            name="prefix",
            metadata_name="",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
            # next is the ListenItem itself (so it is recursive)
            next=actual,
        )
        self.assertEqual(actual, expected)
Beispiel #11
0
    def test_listener_parser_trait_of_trait_dot(self):
        text = "parent.child"
        parser = traits_listener.ListenerParser(text=text)

        # then
        common_traits = dict(
            metadata_name="",
            metadata_defined=True,
            is_any_trait=False,
            dispatch="",
            notify=True,
            is_list_handler=False,
            type=traits_listener.ANY_LISTENER,
        )
        expected_child = traits_listener.ListenerItem(name="child",
                                                      next=None,
                                                      **common_traits)
        expected_parent = traits_listener.ListenerItem(name="parent",
                                                       next=expected_child,
                                                       **common_traits)
        self.assertEqual(parser.listener, expected_parent)
Beispiel #12
0
    def test_parse_square_bracket_in_middle(self):
        text = "foo.[bar, baz]"
        parser = traits_listener.ListenerParser(text=text)

        actual_foo = parser.listener
        # next is a ListenerGroup, and is checked separately
        actual_next = actual_foo.next
        actual_foo.next = None

        common_traits = dict(metadata_name="",
                             metadata_defined=True,
                             is_any_trait=False,
                             dispatch="",
                             notify=True,
                             is_list_handler=False,
                             type=traits_listener.ANY_LISTENER,
                             next=None)
        expected_foo = traits_listener.ListenerItem(
            name="foo",
            **common_traits,
        )
        self.assertEqual(actual_foo, expected_foo)

        # Next listener is a ListenerGroup
        expected_items = [
            traits_listener.ListenerItem(
                name="bar",
                **common_traits,
            ),
            traits_listener.ListenerItem(
                name="baz",
                **common_traits,
            ),
        ]
        self.assertEqual(len(actual_next.items), len(expected_items))
        for actual, expected in zip(actual_next.items, expected_items):
            self.assertEqual(actual, expected)
Beispiel #13
0
 def test_parse_comma_separated_text_trailing_comma(self):
     # Made illegal, see enthought/traits#406
     text = "child1, child2, child3,"
     with self.assertRaises(TraitError):
         traits_listener.ListenerParser(text=text)