コード例 #1
0
    def test_apply(self):
        result_queryset = RunQueryManager.apply(query_spec=self.query1,
                                                queryset=Run.objects)
        expected_query = str(
            Run.objects.filter(
                Q(updated_at__lte="2020-10-10"),
                Q(started_at__gt="2010-10-10"),
                ~Q(started_at="2016-10-01"),
            ).query)
        assert str(result_queryset.query) == expected_query

        result_queryset = RunQueryManager.apply(query_spec=self.query2,
                                                queryset=Run.objects)
        expected_query = str(
            Run.objects.filter(Q(outputs__loss__lte=0.8),
                               Q(status__in=["starting", "running"])).query)
        assert str(result_queryset.query) == expected_query

        result_queryset = RunQueryManager.apply(query_spec=self.query4,
                                                queryset=Run.objects)
        expected_query = str(
            Run.objects.filter(~Q(tags__overlap=["tag1", "tag2"]),
                               Q(tags__contains=["tag3"])).query)
        assert str(result_queryset.query) == expected_query

        result_queryset = RunQueryManager.apply(query_spec=self.query5,
                                                queryset=Run.objects)
        expected_query = str(
            Run.objects.filter(Q(name__icontains="foo"),
                               ~Q(description__istartswith="bal")).query)
        assert str(result_queryset.query) == expected_query
コード例 #2
0
    def test_build(self):
        tokenized_query = RunQueryManager.tokenize(self.query1)
        parsed_query = RunQueryManager.parse(tokenized_query)
        built_query = RunQueryManager.build(parsed_query)
        assert built_query == {
            "updated_at": [
                QueryCondSpec(DateTimeCondition(op="<=", negation=False),
                              params="2020-10-10")
            ],
            "started_at": [
                QueryCondSpec(DateTimeCondition(op=">", negation=False),
                              params="2010-10-10"),
                QueryCondSpec(DateTimeCondition(op="=", negation=True),
                              params="2016-10-01"),
            ],
        }

        tokenized_query = RunQueryManager.tokenize(self.query2)
        parsed_query = RunQueryManager.parse(tokenized_query)
        built_query = RunQueryManager.build(parsed_query)
        assert built_query == {
            "metrics.loss": [
                QueryCondSpec(ComparisonCondition(op="<=", negation=False),
                              params=0.8)
            ],
            "status": [
                QueryCondSpec(
                    ValueCondition(op="|", negation=False),
                    params=["starting", "running"],
                )
            ],
        }

        tokenized_query = RunQueryManager.tokenize(self.query3)
        parsed_query = RunQueryManager.parse(tokenized_query)
        built_query = RunQueryManager.build(parsed_query)
        assert built_query == {
            "finished_at": [
                QueryCondSpec(
                    DateTimeCondition(op="..", negation=False),
                    params=["2012-12-12", "2042-12-12"],
                )
            ]
        }

        tokenized_query = RunQueryManager.tokenize(self.query4)
        parsed_query = RunQueryManager.parse(tokenized_query)
        built_query = RunQueryManager.build(parsed_query)
        assert built_query == {
            "tags": [
                QueryCondSpec(ArrayCondition(op="|", negation=True),
                              params=["tag1", "tag2"]),
                QueryCondSpec(ArrayCondition(op="=", negation=False),
                              params="tag3"),
            ]
        }

        tokenized_query = RunQueryManager.tokenize(self.query5)
        parsed_query = RunQueryManager.parse(tokenized_query)
        built_query = RunQueryManager.build(parsed_query)
        assert built_query == {
            "name": [
                QueryCondSpec(SearchCondition(op="%%", negation=False),
                              params="foo")
            ],
            "description": [
                QueryCondSpec(SearchCondition(op="_%", negation=True),
                              params="bal")
            ],
        }

        tokenized_query = RunQueryManager.tokenize(self.query7)
        parsed_query = RunQueryManager.parse(tokenized_query)
        built_query = RunQueryManager.build(parsed_query)
        assert built_query == {
            "metrics.loss": [
                QueryCondSpec(SearchCondition(op="nil", negation=False),
                              params=None)
            ],
            "status": [
                QueryCondSpec(SearchCondition(op="nil", negation=True),
                              params=None)
            ],
        }