Python ContextStack.get方法代码示例

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_dot_notation__missing_attr_or_key(self):
        name = "foo.bar.baz.bak"
        stack = ContextStack({"foo": {"bar": {}}})
        self.assertString(stack.get(name), "")

        stack = ContextStack({"foo": Attachable(bar=Attachable())})
        self.assertString(stack.get(name), "")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_dot_notation__missing_part_terminates_search(self):
        """
        Test that dotted name resolution terminates on a later part not found.

        Check that if a later dotted name part is not found in the result from
        the former resolution, then name resolution terminates rather than
        starting the search over with the next element of the context stack.
        From the spec (interpolation section)--

          5) If any name parts were retained in step 1, each should be resolved
          against a context stack containing only the result from the former
          resolution.  If any part fails resolution, the result should be considered
          falsey, and should interpolate as the empty string.

        This test case is equivalent to the test case in the following pull
        request:

          https://github.com/mustache/spec/pull/48

        """
        stack = ContextStack({'a': {'b': 'A.B'}}, {'a': 'A'})
        self.assertEqual(stack.get('a'), 'A')
        self.assertException(KeyNotFoundError, "Key 'a.b' not found: missing 'b'", stack.get, "a.b")
        stack.pop()
        self.assertEqual(stack.get('a.b'), 'A.B')

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_top(self):
        key = "foo"
        context = ContextStack({key: "bar"}, {key: "buzz"})
        self.assertEqual(context.get(key), "buzz")

        top = context.top()
        self.assertEqual(top, {"foo": "buzz"})
        # Make sure calling top() didn't remove the item from the stack.
        self.assertEqual(context.get(key), "buzz")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_dot_notation__dict(self):
        name = "foo.bar"
        stack = ContextStack({"foo": {"bar": "baz"}})
        self.assertEqual(stack.get(name), "baz")

        # Works all the way down
        name = "a.b.c.d.e.f.g"
        stack = ContextStack({"a": {"b": {"c": {"d": {"e": {"f": {"g": "w00t!"}}}}}}})
        self.assertEqual(stack.get(name), "w00t!")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_dot_notation_escaped(self):
        name = "foo\.bar"
        stack = ContextStack({"foo.bar": "baz"})
        self.assertEqual(stack.get(name), "baz")

        # Works at any component depth.
        name = "zoo.foo\.bar"
        stack = ContextStack({"zoo": {"foo.bar": "baz"}})
        self.assertEqual(stack.get(name), "baz")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_dot_notation__user_object(self):
        name = "foo.bar"
        stack = ContextStack({"foo": Attachable(bar="baz")})
        self.assertEqual(stack.get(name), "baz")

        # Works on multiple levels, too
        name = "a.b.c.d.e.f.g"
        A = Attachable
        stack = ContextStack({"a": A(b=A(c=A(d=A(e=A(f=A(g="w00t!"))))))})
        self.assertEqual(stack.get(name), "w00t!")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_push(self):
        """
        Test push().

        """
        key = "foo"
        context = ContextStack({key: "bar"})
        self.assertEqual(context.get(key), "bar")

        context.push({key: "buzz"})
        self.assertEqual(context.get(key), "buzz")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_pop(self):
        """
        Test pop().

        """
        key = "foo"
        context = ContextStack({key: "bar"}, {key: "buzz"})
        self.assertEqual(context.get(key), "buzz")

        item = context.pop()
        self.assertEqual(item, {"foo": "buzz"})
        self.assertEqual(context.get(key), "bar")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_dot_notation__autocall(self):
        name = "foo.bar.baz"

        # When any element in the path is callable, it should be automatically invoked
        stack = ContextStack({"foo": Attachable(bar=Attachable(baz=lambda: "Called!"))})
        self.assertEqual(stack.get(name), "Called!")

        class Foo(object):
            def bar(self):
                return Attachable(baz='Baz')

        stack = ContextStack({"foo": Foo()})
        self.assertEqual(stack.get(name), "Baz")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_copy(self):
        key = "foo"
        original = ContextStack({key: "bar"}, {key: "buzz"})
        self.assertEqual(original.get(key), "buzz")

        new = original.copy()
        # Confirm that the copy behaves the same.
        self.assertEqual(new.get(key), "buzz")
        # Change the copy, and confirm it is changed.
        new.pop()
        self.assertEqual(new.get(key), "bar")
        # Confirm the original is unchanged.
        self.assertEqual(original.get(key), "buzz")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_get__default(self):
        """
        Test that get() respects the default value.

        """
        context = ContextStack()
        self.assertEqual(context.get("foo", "bar"), "bar")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_get__single_dot(self):
        """
        Test getting a single dot (".").

        """
        context = ContextStack("a", "b")
        self.assertEqual(context.get("."), "b")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_get__key_present(self):
        """
        Test getting a key.

        """
        context = ContextStack({"foo": "bar"})
        self.assertEqual(context.get("foo"), "bar")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_get__precedence(self):
        """
        Test that get() respects the order of precedence (later items first).

        """
        context = ContextStack({"foo": "bar"}, {"foo": "buzz"})
        self.assertEqual(context.get("foo"), "buzz")

# 需要导入模块: from pystache.context import ContextStack [as 别名]
# 或者: from pystache.context.ContextStack import get [as 别名]
    def test_get__fallback(self):
        """
        Check that first-added stack items are queried on context misses.

        """
        context = ContextStack({"fuzz": "buzz"}, {"foo": "bar"})
        self.assertEqual(context.get("fuzz"), "buzz")