예제 #1
0
 def test_init(self):
     w = xso_query.where(unittest.mock.sentinel.expr)
     self.assertIs(w.expr, unittest.mock.sentinel.expr)
예제 #2
0
 def test_init(self):
     w = xso_query.where(unittest.mock.sentinel.expr)
     self.assertIs(w.expr, unittest.mock.sentinel.expr)
예제 #3
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",
        ])
예제 #4
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",
            ]
        )