Example #1
0
    def test_with_fields(self):
        "Fields dict returned when with_fields"
        safe_fields, singletag_fields, tag_fields, field_lookup = _split_kwargs(
            self.test_model,
            {
                'name': 'Adam',
                'singletag': 'Mr',
                'tags': 'red, blue',
            },
            with_fields=True,
        )
        self.assertEqual(len(safe_fields), 1)
        self.assertEqual(len(singletag_fields), 1)
        self.assertEqual(len(tag_fields), 1)

        self.assertEqual(len(field_lookup), 3)
        self.assertEqual(
            field_lookup['name'],
            test_models.MixedTest._meta.get_field('name'),
        )
        self.assertEqual(
            field_lookup['singletag'],
            test_models.MixedTest._meta.get_field('singletag'),
        )
        self.assertEqual(
            field_lookup['tags'],
            test_models.MixedTest._meta.get_field('tags'),
        )
 def test_with_fields(self):
     "Fields dict returned when with_fields"
     safe_fields, singletag_fields, tag_fields, field_lookup = _split_kwargs(
         self.test_model, {
             'name': 'Adam',
             'singletag': 'Mr',
             'tags': 'red, blue',
         }, with_fields=True,
     )
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(len(singletag_fields), 1)
     self.assertEqual(len(tag_fields), 1)
     
     self.assertEqual(len(field_lookup), 3)
     self.assertEqual(
         field_lookup['name'],
         test_models.MixedTest._meta.get_field('name'),
     )
     self.assertEqual(
         field_lookup['singletag'],
         test_models.MixedTest._meta.get_field('singletag'),
     )
     self.assertEqual(
         field_lookup['tags'],
         test_models.MixedTest._meta.get_field('tags'),
     )
Example #3
0
 def test_unknown(self):
     "Unknown fields passed as safe"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {"unknown": "field"})
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(safe_fields["unknown"], "field")
     self.assertEqual(len(singletag_fields), 0)
     self.assertEqual(len(tag_fields), 0)
Example #4
0
 def test_lookups_unknown(self):
     "Unknown fields in lookups passed as safe"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {"unknown__exact": "field"}, lookups=True)
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(safe_fields["unknown__exact"], "field")
     self.assertEqual(len(singletag_fields), 0)
     self.assertEqual(len(tag_fields), 0)
Example #5
0
 def test_unknown(self):
     "Unknown fields passed as safe"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {
             'unknown': 'field',
         })
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(safe_fields['unknown'], 'field')
     self.assertEqual(len(singletag_fields), 0)
     self.assertEqual(len(tag_fields), 0)
 def test_lookups_unknown(self):
     "Unknown fields in lookups passed as safe"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {
             'unknown__exact':  'field',
         }, lookups=True,
     )
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(safe_fields['unknown__exact'], 'field')
     self.assertEqual(len(singletag_fields), 0)
     self.assertEqual(len(tag_fields), 0)
Example #7
0
    def test_lookups_normal(self):
        "Test with lookups enabled but normal tag"
        safe_fields, singletag_fields, tag_fields = _split_kwargs(
            self.test_model, {"tags": "red"}, lookups=True)

        # Unknown lookups are passed straight
        self.assertEqual(len(safe_fields), 0)
        self.assertEqual(len(singletag_fields), 0)

        self.assertEqual(len(tag_fields), 1)
        self.assertEqual(tag_fields["tags"], ("red", None))
 def test_unknown(self):
     "Unknown fields passed as safe"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {
             'unknown':  'field',
         }
     )
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(safe_fields['unknown'], 'field')
     self.assertEqual(len(singletag_fields), 0)
     self.assertEqual(len(tag_fields), 0)
Example #9
0
 def test_lookups_unknown(self):
     "Unknown fields in lookups passed as safe"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model,
         {
             'unknown__exact': 'field',
         },
         lookups=True,
     )
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(safe_fields['unknown__exact'], 'field')
     self.assertEqual(len(singletag_fields), 0)
     self.assertEqual(len(tag_fields), 0)
 def test_lookups_normal(self):
     "Test with lookups enabled but normal tag"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {
             'tags': 'red',
         }, lookups=True,
     )
     
     # Unknown lookups are passed straight
     self.assertEqual(len(safe_fields), 0)
     self.assertEqual(len(singletag_fields), 0)
     
     self.assertEqual(len(tag_fields), 1)
     self.assertEqual(tag_fields['tags'], ('red', None))
Example #11
0
    def test_fields(self):
        "Look up known fields"
        safe_fields, singletag_fields, tag_fields = _split_kwargs(
            self.test_model, {
                "name": "Adam",
                "singletag": "Mr",
                "tags": "red, blue"
            })
        self.assertEqual(len(safe_fields), 1)
        self.assertEqual(safe_fields["name"], "Adam")

        self.assertEqual(len(singletag_fields), 1)
        self.assertEqual(singletag_fields["singletag"], "Mr")

        self.assertEqual(len(tag_fields), 1)
        self.assertEqual(tag_fields["tags"], "red, blue")
Example #12
0
    def test_fields(self):
        "Look up known fields"
        safe_fields, singletag_fields, tag_fields = _split_kwargs(
            self.test_model, {
                'name': 'Adam',
                'singletag': 'Mr',
                'tags': 'red, blue',
            })
        self.assertEqual(len(safe_fields), 1)
        self.assertEqual(safe_fields['name'], 'Adam')

        self.assertEqual(len(singletag_fields), 1)
        self.assertEqual(singletag_fields['singletag'], 'Mr')

        self.assertEqual(len(tag_fields), 1)
        self.assertEqual(tag_fields['tags'], 'red, blue')
 def test_fields(self):
     "Look up known fields"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {
             'name': 'Adam',
             'singletag': 'Mr',
             'tags': 'red, blue',
         }
     )
     self.assertEqual(len(safe_fields), 1)
     self.assertEqual(safe_fields['name'], 'Adam')
     
     self.assertEqual(len(singletag_fields), 1)
     self.assertEqual(singletag_fields['singletag'], 'Mr')
     
     self.assertEqual(len(tag_fields), 1)
     self.assertEqual(tag_fields['tags'], 'red, blue')
 def test_lookups(self):
     "Test with lookups enabled"
     safe_fields, singletag_fields, tag_fields = _split_kwargs(
         self.test_model, {
             'name__startswith': 'Ad',
             'singletag__name__contains': 'r',
             'tags__name__contains': 'e',
             'tags__exact': 'red, blue',
         }, lookups=True,
     )
     
     # Unknown lookups are passed straight
     self.assertEqual(len(safe_fields), 3)
     self.assertEqual(safe_fields['name__startswith'], 'Ad')
     self.assertEqual(safe_fields['singletag__name__contains'], 'r')
     self.assertEqual(safe_fields['tags__name__contains'], 'e')
     
     self.assertEqual(len(singletag_fields), 0)
     
     self.assertEqual(len(tag_fields), 1)
     self.assertEqual(tag_fields['tags'], ('red, blue', 'exact'))
Example #15
0
    def test_lookups(self):
        "Test with lookups enabled"
        safe_fields, singletag_fields, tag_fields = _split_kwargs(
            self.test_model,
            {
                'name__startswith': 'Ad',
                'singletag__name__contains': 'r',
                'tags__name__contains': 'e',
                'tags__exact': 'red, blue',
            },
            lookups=True,
        )

        # Unknown lookups are passed straight
        self.assertEqual(len(safe_fields), 3)
        self.assertEqual(safe_fields['name__startswith'], 'Ad')
        self.assertEqual(safe_fields['singletag__name__contains'], 'r')
        self.assertEqual(safe_fields['tags__name__contains'], 'e')

        self.assertEqual(len(singletag_fields), 0)

        self.assertEqual(len(tag_fields), 1)
        self.assertEqual(tag_fields['tags'], ('red, blue', 'exact'))
Example #16
0
    def test_lookups(self):
        "Test with lookups enabled"
        safe_fields, singletag_fields, tag_fields = _split_kwargs(
            self.test_model,
            {
                "name__startswith": "Ad",
                "singletag__name__contains": "r",
                "tags__name__contains": "e",
                "tags__exact": "red, blue",
            },
            lookups=True,
        )

        # Unknown lookups are passed straight
        self.assertEqual(len(safe_fields), 3)
        self.assertEqual(safe_fields["name__startswith"], "Ad")
        self.assertEqual(safe_fields["singletag__name__contains"], "r")
        self.assertEqual(safe_fields["tags__name__contains"], "e")

        self.assertEqual(len(singletag_fields), 0)

        self.assertEqual(len(tag_fields), 1)
        self.assertEqual(tag_fields["tags"], ("red, blue", "exact"))
Example #17
0
    def test_with_fields(self):
        "Fields dict returned when with_fields"
        safe_fields, singletag_fields, tag_fields, field_lookup = _split_kwargs(
            self.test_model,
            {
                "name": "Adam",
                "singletag": "Mr",
                "tags": "red, blue"
            },
            with_fields=True,
        )
        self.assertEqual(len(safe_fields), 1)
        self.assertEqual(len(singletag_fields), 1)
        self.assertEqual(len(tag_fields), 1)

        self.assertEqual(len(field_lookup), 3)
        self.assertEqual(field_lookup["name"],
                         test_models.MixedTest._meta.get_field("name"))
        self.assertEqual(
            field_lookup["singletag"],
            test_models.MixedTest._meta.get_field("singletag"),
        )
        self.assertEqual(field_lookup["tags"],
                         test_models.MixedTest._meta.get_field("tags"))