gistfile1.txt

(djtrunk)danielpiros@monkey:~/.virtualenvs/djtrunk/django-trunk/tests$ PYTHONPATH=..:$PYTHONPATH ./runtests.py model_meta.test
Testing against Django installed in '/Users/danielpiros/.virtualenvs/djtrunk/django-trunk/django'
Creating test database for alias 'default'...
Creating test database for alias 'other'...
................
----------------------------------------------------------------------
Ran 16 tests in 0.008s

OK
Destroying test database for alias 'default'...
Destroying test database for alias 'other'...
(djtrunk)danielpiros@monkey:~/.virtualenvs/djtrunk/django-trunk/tests$ PYTHONPATH=..:$PYTHONPATH ./runtests.py model_meta.test_refactored
Testing against Django installed in '/Users/danielpiros/.virtualenvs/djtrunk/django-trunk/django'
Creating test database for alias 'default'...
Creating test database for alias 'other'...
................
----------------------------------------------------------------------
Ran 16 tests in 0.045s

OK
Destroying test database for alias 'default'...
Destroying test database for alias 'other'...
(djtrunk)danielpiros@monkey:~/.virtualenvs/djtrunk/django-trunk/tests$ 

options.py

    @lru_cache(maxsize=1000)
    def get_new_fields(self, types, opts=NONE, **kwargs):
        fields = OrderedDict()

        if types & VIRTUAL:
            for field in self.virtual_fields:
                fields[field] = True

        if types & DATA:
            if not opts & LOCAL_ONLY:
                for parent in self.parents:
                    fields.update(parent._meta.get_new_fields(types=DATA,
                                  opts=opts, **dict(kwargs, recursive=True)))
            for field in self.local_fields:
                if not ((opts & CONCRETE) and field.column is None):
                    fields[field] = True

        if types & M2M:
            if not opts & LOCAL_ONLY:
                for parent in self.parents:
                    fields.update(parent._meta.get_new_fields(types=M2M,
                                  opts=opts, **dict(kwargs, recursive=True)))
            for field in self.local_many_to_many:
                fields[field] = True

        if types & RELATED_M2M:
            related_m2m_fields = OrderedDict()
            if not (opts & LOCAL_ONLY):
                for parent in self.parents:
                    for obj in parent._meta.get_new_fields(types=RELATED_M2M, **kwargs):
                        is_valid = not (obj.field.creation_counter < 0
                                    and obj.model not in self.get_parent_list())
                        if is_valid:
                            related_m2m_fields[obj] = True

            for model in self.get_non_swapped_models(False):
                for f in model._meta.get_new_fields(types=M2M):
                    has_rel_attr = f.rel and not isinstance(f.rel.to, six.string_types)
                    if has_rel_attr and self == f.rel.to._meta:
                        related_m2m_fields[f.related] = True

            fields.update(related_m2m_fields)

        if types & RELATED_OBJECTS:
            related_fields = OrderedDict()
            # ERROR? check
            if not (opts & LOCAL_ONLY):
                for parent in self.parents:
                    for obj in parent._meta.get_new_fields(types=RELATED_OBJECTS,
                                                           opts=INCLUDE_HIDDEN, **kwargs):
                        if self._validate_related_object(obj):
                            related_fields[obj] = True

            for model in self.get_non_swapped_models(True):
                for f in model._meta.get_new_fields(types=DATA | VIRTUAL,
                                                    opts=INCLUDE_HIDDEN):
                    has_rel_attr = hasattr(f, 'rel') and f.rel
                    if has_rel_attr and f.has_class_relation():
                        to_meta = f.rel.to._meta
                        if (to_meta == self) or ((opts & INCLUDE_PROXY)
                                and self.concrete_model == to_meta.concrete_model):
                            related_fields[f.related] = True

            if not opts & INCLUDE_HIDDEN:
                related_fields = OrderedDict([(k, v) for k, v in related_fields.items()
                                              if not k.field.rel.is_hidden()])
            fields.update(related_fields)

        if not 'recursive' in kwargs:
            fields = tuple(fields.keys())

        return fields

test.py

from django import test

from django.db.models.fields import related, CharField, Field
from django.contrib.contenttypes.fields import GenericForeignKey

from .models import (
    AbstractPerson, BasePerson, Person, Relating, Relation
)

class OptionsBaseTests(test.TestCase):

    def _map_rq_names(self, res):
        return tuple([(o.field.related_query_name(), m) for o, m in res])

    def _map_names(self, res):
        return tuple([(f.name, m) for f, m in res])


class DataTests(OptionsBaseTests):

    def test_fields(self):
        for model, expected_result in TEST_RESULTS['fields'].items():
            fields = model._meta.fields
            self.assertEqual([f.attname for f in fields], expected_result)

    def test_local_fields(self):
        is_data_field = lambda f: isinstance(f, Field) and not isinstance(f, related.ManyToManyField)

        for model, expected_result in TEST_RESULTS['local_fields'].items():
            fields = model._meta.local_fields
            self.assertEqual([f.attname for f in fields], expected_result)
            self.assertTrue(all([f.model is model for f in fields]))
            self.assertTrue(all([is_data_field(f) for f in fields]))

    def test_local_concrete_fields(self):
        for model, expected_result in TEST_RESULTS['local_concrete_fields'].items():
            fields = model._meta.local_concrete_fields
            self.assertEqual([f.attname for f in fields], expected_result)
            self.assertTrue(all([f.column is not None for f in fields]))


class M2MTests(OptionsBaseTests):

    def test_many_to_many(self):
        for model, expected_result in TEST_RESULTS['many_to_many'].items():
            fields = model._meta.many_to_many
            self.assertEqual([f.attname for f in fields], expected_result)
            self.assertTrue(all([isinstance(f.rel, related.ManyToManyRel)
                                 for f in fields]))

    def test_many_to_many_with_model(self):
        for model, expected_result in TEST_RESULTS['many_to_many_with_model'].items():
            models = [model for field, model in model._meta.get_m2m_with_model()]
            self.assertEqual(models, expected_result)


class RelatedObjectsTests(OptionsBaseTests):
    def setUp(self):
        self.key_name = lambda r: r[0]

    def test_related_objects(self):
        result_key = 'get_all_related_objects_with_model'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_objects_with_model()
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_objects_local(self):
        result_key = 'get_all_related_objects_with_model_local'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_objects_with_model(local_only=True)
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_objects_include_hidden(self):
        result_key = 'get_all_related_objects_with_model_hidden'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_objects_with_model(include_hidden=True)
            self.assertEqual(
                sorted(self._map_names(objects), key=self.key_name),
                sorted(expected, key=self.key_name)
            )

    def test_related_objects_include_hidden_local_only(self):
        result_key = 'get_all_related_objects_with_model_hidden_local'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_objects_with_model(
                include_hidden=True, local_only=True)
            self.assertEqual(
                sorted(self._map_names(objects), key=self.key_name),
                sorted(expected, key=self.key_name)
            )

    def test_related_objects_proxy(self):
        result_key = 'get_all_related_objects_with_model_proxy'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_objects_with_model(
                include_proxy_eq=True)
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_objects_proxy_hidden(self):
        result_key = 'get_all_related_objects_with_model_proxy_hidden'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_objects_with_model(
                include_proxy_eq=True, include_hidden=True)
            self.assertEqual(
                sorted(self._map_names(objects), key=self.key_name),
                sorted(expected, key=self.key_name)
            )


class RelatedM2MTests(OptionsBaseTests):

    def test_related_m2m_with_model(self):
        result_key = 'get_all_related_many_to_many_with_model'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_m2m_objects_with_model()
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_m2m_local_only(self):
        result_key = 'get_all_related_many_to_many_local'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_all_related_many_to_many_objects(
                local_only=True)
            self.assertEqual([o.field.related_query_name()
                              for o in objects], expected)

    def test_related_m2m_asymmetrical(self):
        m2m = Person._meta.many_to_many
        self.assertTrue('following_base' in [f.attname for f in m2m])
        related_m2m = Person._meta.get_all_related_many_to_many_objects()
        self.assertTrue('followers_base' in [o.field.related_query_name() for o in related_m2m])

    def test_related_m2m_symmetrical(self):
        m2m = Person._meta.many_to_many
        self.assertTrue('friends_base' in [f.attname for f in m2m])
        related_m2m = Person._meta.get_all_related_many_to_many_objects()
        self.assertIn('friends_inherited_rel_+', [o.field.related_query_name() for o in related_m2m])


class VirtualFieldsTests(OptionsBaseTests):

    def test_virtual_fields(self):
        for model, expected_names in TEST_RESULTS['virtual_fields'].items():
            objects = model._meta.virtual_fields
            self.assertEqual(sorted([f.name for f in objects]), sorted(expected_names))


#class GetFieldByNameTests(OptionsBaseTests):

    #def test_get_data_field(self):
        #field_info = Person._meta.get_field_by_name('data_abstract')
        #self.assertEqual(field_info[1:], (BasePerson, True, False))
        #self.assertIsInstance(field_info[0], CharField)

    #def test_get_m2m_field(self):
        #field_info = Person._meta.get_field_by_name('m2m_base')
        #self.assertEqual(field_info[1:], (BasePerson, True, True))
        #self.assertIsInstance(field_info[0], related.ManyToManyField)

    #def test_get_related_object(self):
        #field_info = Person._meta.get_field_by_name('relating_baseperson')
        #self.assertEqual(field_info[1:], (BasePerson, False, False))
        #self.assertIsInstance(field_info[0], related.RelatedObject)

    #def test_get_related_m2m(self):
        #field_info = Person._meta.get_field_by_name('relating_people')
        #self.assertEqual(field_info[1:], (None, False, True))
        #self.assertIsInstance(field_info[0], related.RelatedObject)

    #def test_get_virtual_field(self):
        #field_info = Person._meta.get_field_by_name('content_object_base')
        #self.assertEqual(field_info[1:], (None, True, False))
        #self.assertIsInstance(field_info[0], GenericForeignKey)

test_refactored.py

from django import test

from django.db.models.fields import related, CharField, Field
from django.contrib.contenttypes.fields import GenericForeignKey
from django.db.models.options import (
    DATA, M2M, RELATED_OBJECTS, RELATED_M2M, VIRTUAL,
    LOCAL_ONLY, CONCRETE, INCLUDE_HIDDEN, INCLUDE_PROXY
)

from .models import (
    AbstractPerson, BasePerson, Person, Relating, Relation
)


class OptionsBaseTests(test.TestCase):

    def _map_rq_names(self, res):
        return tuple([(o.field.related_query_name(), m) for o, m in res])

    def _map_names(self, res):
        return tuple([(f.name, m) for f, m in res])

    def _model(self, current_model, field):
        direct = isinstance(field, Field) or isinstance(field, GenericForeignKey)
        model = field.model if direct else field.parent_model._meta.concrete_model
        return None if model == current_model else model


class DataTests(OptionsBaseTests):

    def test_fields(self):
        for model, expected_result in TEST_RESULTS['fields'].items():
            fields = model._meta.get_new_fields(types=DATA)
            self.assertEqual([f.attname for f in fields], expected_result)

    def test_local_fields(self):
        is_data_field = lambda f: isinstance(f, Field) and not isinstance(f, related.ManyToManyField)

        for model, expected_result in TEST_RESULTS['local_fields'].items():
            fields = model._meta.get_new_fields(types=DATA, opts=LOCAL_ONLY)
            self.assertEqual([f.attname for f in fields], expected_result)
            self.assertTrue(all([f.model is model for f in fields]))
            self.assertTrue(all([is_data_field(f) for f in fields]))

    def test_local_concrete_fields(self):
        for model, expected_result in TEST_RESULTS['local_concrete_fields'].items():
            fields = model._meta.get_new_fields(types=DATA, opts=LOCAL_ONLY | CONCRETE)
            self.assertEqual([f.attname for f in fields], expected_result)
            self.assertTrue(all([f.column is not None for f in fields]))


class M2MTests(OptionsBaseTests):

    def test_many_to_many(self):
        for model, expected_result in TEST_RESULTS['many_to_many'].items():
            fields = model._meta.get_new_fields(types=M2M)
            self.assertEqual([f.attname for f in fields], expected_result)
            self.assertTrue(all([isinstance(f.rel, related.ManyToManyRel)
                                 for f in fields]))

    def test_many_to_many_with_model(self):
        for model, expected_result in TEST_RESULTS['many_to_many_with_model'].items():
            models = [self._model(model, field) for field in model._meta.get_new_fields(types=M2M)]
            self.assertEqual(models, expected_result)


class RelatedObjectsTests(OptionsBaseTests):
    def setUp(self):
        self.key_name = lambda r: r[0]

    def test_related_objects(self):
        result_key = 'get_all_related_objects_with_model'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = [(field, self._model(model, field))
                       for field in model._meta.get_new_fields(types=RELATED_OBJECTS)]
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_objects_local(self):
        result_key = 'get_all_related_objects_with_model_local'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = [(field, self._model(model, field))
                       for field in model._meta.get_new_fields(types=RELATED_OBJECTS, opts=LOCAL_ONLY)]
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_objects_include_hidden(self):
        result_key = 'get_all_related_objects_with_model_hidden'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = [(field, self._model(model, field))
                       for field in model._meta.get_new_fields(types=RELATED_OBJECTS, opts=INCLUDE_HIDDEN)]
            self.assertEqual(
                sorted(self._map_names(objects), key=self.key_name),
                sorted(expected, key=self.key_name)
            )

    def test_related_objects_include_hidden_local_only(self):
        result_key = 'get_all_related_objects_with_model_hidden_local'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = [(field, self._model(model, field))
                       for field in model._meta.get_new_fields(types=RELATED_OBJECTS, opts=INCLUDE_HIDDEN | LOCAL_ONLY)]
            self.assertEqual(
                sorted(self._map_names(objects), key=self.key_name),
                sorted(expected, key=self.key_name)
            )

    def test_related_objects_proxy(self):
        result_key = 'get_all_related_objects_with_model_proxy'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = [(field, self._model(model, field))
                       for field in model._meta.get_new_fields(types=RELATED_OBJECTS, opts=INCLUDE_PROXY)]
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_objects_proxy_hidden(self):
        result_key = 'get_all_related_objects_with_model_proxy_hidden'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = [(field, self._model(model, field))
                       for field in model._meta.get_new_fields(types=RELATED_OBJECTS, opts=INCLUDE_PROXY | INCLUDE_HIDDEN)]
            self.assertEqual(
                sorted(self._map_names(objects), key=self.key_name),
                sorted(expected, key=self.key_name)
            )


class RelatedM2MTests(OptionsBaseTests):

    def test_related_m2m_with_model(self):
        result_key = 'get_all_related_many_to_many_with_model'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = [(field, self._model(model, field))
                       for field in model._meta.get_new_fields(types=RELATED_M2M)]
            self.assertEqual(self._map_rq_names(objects), expected)

    def test_related_m2m_local_only(self):
        result_key = 'get_all_related_many_to_many_local'
        for model, expected in TEST_RESULTS[result_key].items():
            objects = model._meta.get_new_fields(types=RELATED_M2M, opts=LOCAL_ONLY)
            self.assertEqual([o.field.related_query_name()
                              for o in objects], expected)

    def test_related_m2m_asymmetrical(self):
        m2m = Person._meta.get_new_fields(types=M2M)
        self.assertTrue('following_base' in [f.attname for f in m2m])
        related_m2m = Person._meta.get_new_fields(types=RELATED_M2M)
        self.assertTrue('followers_base' in [o.field.related_query_name() for o in related_m2m])

    def test_related_m2m_symmetrical(self):
        m2m = Person._meta.get_new_fields(types=M2M)
        self.assertTrue('friends_base' in [f.attname for f in m2m])
        related_m2m = Person._meta.get_new_fields(types=RELATED_M2M)
        self.assertIn('friends_inherited_rel_+', [o.field.related_query_name() for o in related_m2m])


class VirtualFieldsTests(OptionsBaseTests):

    def test_virtual_fields(self):
        for model, expected_names in TEST_RESULTS['virtual_fields'].items():
            objects = model._meta.get_new_fields(types=VIRTUAL)
            self.assertEqual(sorted([f.name for f in objects]), sorted(expected_names))


#class GetFieldByNameTests(OptionsBaseTests):

    #def test_get_data_field(self):
        #field_info = Person._meta.get_field_by_name('data_abstract')
        #self.assertEqual(field_info[1:], (BasePerson, True, False))
        #self.assertIsInstance(field_info[0], CharField)

    #def test_get_m2m_field(self):
        #field_info = Person._meta.get_field_by_name('m2m_base')
        #self.assertEqual(field_info[1:], (BasePerson, True, True))
        #self.assertIsInstance(field_info[0], related.ManyToManyField)

    #def test_get_related_object(self):
        #field_info = Person._meta.get_field_by_name('relating_baseperson')
        #self.assertEqual(field_info[1:], (BasePerson, False, False))
        #self.assertIsInstance(field_info[0], related.RelatedObject)

    #def test_get_related_m2m(self):
        #field_info = Person._meta.get_field_by_name('relating_people')
        #self.assertEqual(field_info[1:], (None, False, True))
        #self.assertIsInstance(field_info[0], related.RelatedObject)

    #def test_get_virtual_field(self):
        #field_info = Person._meta.get_field_by_name('content_object_base')
        #self.assertEqual(field_info[1:], (None, True, False))
        #self.assertIsInstance(field_info[0], GenericForeignKey)

model_meta.test -> the old API
model_meta.test_refactored -> the new API