Example #1
0
    def test_not(self):
        expr1 = xso_query._ExprMixin()

        def as_exprs():
            yield unittest.mock.sentinel.expr1

        with contextlib.ExitStack() as stack:
            as_expr = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.as_expr"))
            as_expr.side_effect = as_exprs()

            NotOp = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.NotOp"))

            result = xso_query.not_(expr1)

        self.assertSequenceEqual(as_expr.mock_calls, [
            unittest.mock.call(expr1),
        ])

        NotOp.assert_called_with(unittest.mock.sentinel.expr1, )

        self.assertEqual(
            result,
            NotOp(),
        )
Example #2
0
    def test_not(self):
        expr1 = xso_query._ExprMixin()

        def as_exprs():
            yield unittest.mock.sentinel.expr1

        with contextlib.ExitStack() as stack:
            as_expr = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.as_expr")
            )
            as_expr.side_effect = as_exprs()

            NotOp = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.NotOp")
            )

            result = xso_query.not_(expr1)

        self.assertSequenceEqual(
            as_expr.mock_calls,
            [
                unittest.mock.call(expr1),
            ]
        )

        NotOp.assert_called_with(
            unittest.mock.sentinel.expr1,
        )

        self.assertEqual(
            result,
            NotOp(),
        )
Example #3
0
    def test_uses_as_expr(self):
        expr = unittest.mock.sentinel.expr

        with contextlib.ExitStack() as stack:
            as_expr = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.as_expr"))

            NotOp = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.NotOp"))

            result = xso_query.not_(expr)

        as_expr.assert_called_with(expr)

        NotOp.assert_called_with(as_expr())

        self.assertEqual(result, NotOp())
Example #4
0
    def test_uses_as_expr(self):
        expr = unittest.mock.sentinel.expr

        with contextlib.ExitStack() as stack:
            as_expr = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.as_expr")
            )

            NotOp = stack.enter_context(
                unittest.mock.patch("aioxmpp.xso.query.NotOp")
            )

            result = xso_query.not_(expr)

        as_expr.assert_called_with(expr)

        NotOp.assert_called_with(as_expr())

        self.assertEqual(result, NotOp())
Example #5
0
    def test_xsopath(self):
        xso = RootXSO()
        xso.attr = "root"

        f = FooXSO()
        f.attr = "foo1"
        xso.children.append(f)

        f = BazXSO()
        f.attr2 = "baz1"
        xso.children.append(f)

        f = FooXSO()
        f.attr = "foo2"
        xso.children.append(f)

        f = FooXSO()
        f.attr = "bar1/foo"
        b = BarXSO()
        b.child = f
        xso.children.append(b)

        ec = xso_query.EvaluationContext()
        ec.set_toplevel_object(xso)

        query = xso_query.as_expr(RootXSO.children / BarXSO.child /
                                  FooXSO.attr)

        self.assertSequenceEqual(list(query.eval(ec)), ["bar1/foo"])

        query = xso_query.as_expr(RootXSO.children / FooXSO.attr)

        self.assertSequenceEqual(list(query.eval(ec)), ["foo1", "foo2"])

        query = xso_query.as_expr(RootXSO.children / FooXSO)

        self.assertSequenceEqual(
            list(query.eval(ec)),
            list(filter(lambda x: isinstance(x, FooXSO), xso.children)))

        query = xso_query.as_expr(RootXSO.children / FooXSO[::2])

        self.assertSequenceEqual(list(query.eval(ec)), [
            xso.children[0],
            xso.children[2],
        ])

        query = xso_query.as_expr(RootXSO.children /
                                  FooXSO[xso_query.where(FooXSO.attr)][:2])

        self.assertSequenceEqual(list(query.eval(ec)), [
            xso.children[0],
            xso.children[2],
        ])

        query = xso_query.as_expr(RootXSO.children /
                                  FooXSO[:2][xso_query.where(FooXSO.attr)])

        self.assertSequenceEqual(list(query.eval(ec)), [
            xso.children[0],
        ])

        query = xso_query.as_expr(RootXSO.children /
                                  FooXSO[xso_query.where(FooXSO.attr)][:2] /
                                  FooXSO.attr)

        self.assertSequenceEqual(list(query.eval(ec)), [
            "foo1",
            "foo2",
        ])

        query = xso_query.as_expr(RootXSO.children /
                                  FooXSO[:2][xso_query.where(FooXSO.attr)] /
                                  FooXSO.attr)

        self.assertSequenceEqual(list(query.eval(ec)), [
            "foo1",
        ])

        query = xso_query.as_expr(
            RootXSO.children /
            FooXSO[:2][xso_query.where(xso_query.not_(FooXSO.attr))])

        self.assertSequenceEqual(list(query.eval(ec)), [xso.children[1]])

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[xso_query.where(FooXSO.attr == "foo1")] /
            FooXSO.attr)

        self.assertSequenceEqual(list(query.eval(ec)), [
            "foo1",
        ])
Example #6
0
    def test_xsopath(self):
        xso = RootXSO()
        xso.attr = "root"

        f = FooXSO()
        f.attr = "foo1"
        xso.children.append(f)

        f = BazXSO()
        f.attr2 = "baz1"
        xso.children.append(f)

        f = FooXSO()
        f.attr = "foo2"
        xso.children.append(f)

        f = FooXSO()
        f.attr = "bar1/foo"
        b = BarXSO()
        b.child = f
        xso.children.append(b)

        ec = xso_query.EvaluationContext()
        ec.set_toplevel_object(xso)

        query = xso_query.as_expr(
            RootXSO.children / BarXSO.child / FooXSO.attr
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            ["bar1/foo"]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO.attr
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            ["foo1", "foo2"]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            list(filter(lambda x: isinstance(x, FooXSO), xso.children))
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[::2]
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            [
                xso.children[0],
                xso.children[2],
            ]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[xso_query.where(FooXSO.attr)][:2]
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            [
                xso.children[0],
                xso.children[2],
            ]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[:2][xso_query.where(FooXSO.attr)]
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            [
                xso.children[0],
            ]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[xso_query.where(FooXSO.attr)][:2] /
            FooXSO.attr
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            [
                "foo1",
                "foo2",
            ]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[:2][xso_query.where(FooXSO.attr)] /
            FooXSO.attr
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            [
                "foo1",
            ]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[:2][
                xso_query.where(xso_query.not_(FooXSO.attr))
            ]
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            [
                xso.children[1]
            ]
        )

        query = xso_query.as_expr(
            RootXSO.children / FooXSO[xso_query.where(FooXSO.attr == "foo1")] /
            FooXSO.attr
        )

        self.assertSequenceEqual(
            list(query.eval(ec)),
            [
                "foo1",
            ]
        )