Exemple #1
0
    def test_range_apply(self):
        ExperimentFactory(name='foo_bar')
        ExperimentFactory(name='foo_moo')
        ExperimentFactory(name='moo_boo')

        contains_cond = SearchCondition(op='icontains')
        ncontains_cond = SearchCondition(op='icontains', negation=True)
        startswith_cond = SearchCondition(op='istartswith')
        nstartswith_cond = SearchCondition(op='istartswith', negation=True)
        endswith_cond = SearchCondition(op='iendswith')
        nendswith_cond = SearchCondition(op='iendswith', negation=True)

        # contains
        queryset = contains_cond.apply(queryset=Experiment.objects,
                                       name='name',
                                       params='foo')
        assert queryset.count() == 2

        queryset = contains_cond.apply(queryset=Experiment.objects,
                                       name='name',
                                       params='bar')
        assert queryset.count() == 1

        queryset = contains_cond.apply(queryset=Experiment.objects,
                                       name='name',
                                       params='boo')
        assert queryset.count() == 1

        queryset = contains_cond.apply(queryset=Experiment.objects,
                                       name='name',
                                       params='none')
        assert queryset.count() == 0

        # ncontains
        queryset = ncontains_cond.apply(queryset=Experiment.objects,
                                        name='name',
                                        params='foo')
        assert queryset.count() == 1

        queryset = ncontains_cond.apply(queryset=Experiment.objects,
                                        name='name',
                                        params='bar')
        assert queryset.count() == 2

        queryset = ncontains_cond.apply(queryset=Experiment.objects,
                                        name='name',
                                        params='boo')
        assert queryset.count() == 2

        queryset = ncontains_cond.apply(queryset=Experiment.objects,
                                        name='name',
                                        params='none')
        assert queryset.count() == 3

        # startswith
        queryset = startswith_cond.apply(queryset=Experiment.objects,
                                         name='name',
                                         params='foo')
        assert queryset.count() == 2

        queryset = startswith_cond.apply(queryset=Experiment.objects,
                                         name='name',
                                         params='bar')
        assert queryset.count() == 0

        queryset = startswith_cond.apply(queryset=Experiment.objects,
                                         name='name',
                                         params='moo')
        assert queryset.count() == 1

        # nstartswith
        queryset = nstartswith_cond.apply(queryset=Experiment.objects,
                                          name='name',
                                          params='foo')
        assert queryset.count() == 1

        queryset = nstartswith_cond.apply(queryset=Experiment.objects,
                                          name='name',
                                          params='bar')
        assert queryset.count() == 3

        queryset = nstartswith_cond.apply(queryset=Experiment.objects,
                                          name='name',
                                          params='moo')
        assert queryset.count() == 2

        # endswith
        queryset = endswith_cond.apply(queryset=Experiment.objects,
                                       name='name',
                                       params='foo')
        assert queryset.count() == 0

        queryset = endswith_cond.apply(queryset=Experiment.objects,
                                       name='name',
                                       params='bar')
        assert queryset.count() == 1

        queryset = endswith_cond.apply(queryset=Experiment.objects,
                                       name='name',
                                       params='moo')
        assert queryset.count() == 1

        # nendswith
        queryset = nendswith_cond.apply(queryset=Experiment.objects,
                                        name='name',
                                        params='foo')
        assert queryset.count() == 3

        queryset = nendswith_cond.apply(queryset=Experiment.objects,
                                        name='name',
                                        params='bar')
        assert queryset.count() == 2

        queryset = nendswith_cond.apply(queryset=Experiment.objects,
                                        name='name',
                                        params='moo')
        assert queryset.count() == 2
Exemple #2
0
 def test_endswith_operators(self):
     op = SearchCondition._endswith_operator('field', 'v1')
     assert op == Q(field__iendswith='v1')
     op = SearchCondition._nendswith_operator('field', 'v1')
     assert op == ~Q(field__iendswith='v1')
Exemple #3
0
 def test_contains_operators(self):
     op = SearchCondition._contains_operator('field', 'v1')
     assert op == Q(field__icontains='v1')
     op = SearchCondition._ncontains_operator('field', 'v1')
     assert op == ~Q(field__icontains='v1')
Exemple #4
0
 def test_startswith_operators(self):
     op = SearchCondition._startswith_operator('field', 'v1')
     assert op == Q(field__istartswith='v1')
     op = SearchCondition._nstartswith_operator('field', 'v1')
     assert op == ~Q(field__istartswith='v1')
Exemple #5
0
    def test_build(self):
        tokenized_query = ExperimentQueryManager.tokenize(self.query1)
        parsed_query = ExperimentQueryManager.parse(tokenized_query)
        built_query = ExperimentQueryManager.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 = ExperimentQueryManager.tokenize(self.query2)
        parsed_query = ExperimentQueryManager.parse(tokenized_query)
        built_query = ExperimentQueryManager.build(parsed_query)
        assert built_query == {
            'metric.loss': [
                QueryCondSpec(ComparisonCondition(op='<=', negation=False),
                              params=0.8)
            ],
            'status': [
                QueryCondSpec(ValueCondition(op='|', negation=False),
                              params=['starting', 'running'])
            ],
        }

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

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

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