def test__get_field__method(self):
data = (
dict(
model=get_model('myapp', 'Model1'),
fields=(('simple_field', models.CharField), ),
),
dict(
model=get_model('myapp', 'Model2'),
fields=(('simple_field', models.CharField), ),
),
dict(
model=get_model('myapp', 'Model3'),
fields=(
('simple_field', models.CharField),
('m2m_field', models.ManyToManyField),
),
),
)
for test_data in data:
model, fields = test_data['model'], test_data['fields']
opts = ModelOptions(model)
for field_name, field_type in fields:
self.assertIsInstance(opts.get_field(field_name), field_type)
f, _, _, _ = opts.get_field_by_name(field_name)
self.assertIsInstance(f, field_type, field_type)
# ---------------------------------------------------------------------
opts = ModelOptions(get_model('myapp', 'Model2'))
field = opts.get_field('fk_field')
related = get_related(field)
self.assertIsNotNone(related)
self.assertIs(related.parent_model, get_model('myapp', 'Model1'))
def test_manager_compat(self):
u"""Проверка совместимости менеджеров моделей."""
model = get_model('myapp', 'ModelWithCustomManager')
self.assertIsNotNone(model)
for i in range(-5, 6):
model.objects.create(number=i)
self.assertIsInstance(model.new_manager.get_query_set(), QuerySet)
self.assertIsInstance(model.new_manager.get_queryset(), QuerySet)
self.assertIsInstance(model.old_manager.get_query_set(), QuerySet)
self.assertIsInstance(model.old_manager.get_queryset(), QuerySet)
self.assertEqual(model.objects.count(), model.old_manager.count())
self.assertEqual(model.objects.count(), model.new_manager.count())
with self.assertNumQueries(1), catch_warnings():
self.assertTrue(
all(obj.number > 0 for obj in model.old_manager.positive()))
with self.assertNumQueries(1), catch_warnings():
self.assertTrue(
all(obj.number < 0 for obj in model.old_manager.negative()))
with self.assertNumQueries(1):
self.assertTrue(
all(obj.number > 0 for obj in model.new_manager.positive()))
with self.assertNumQueries(1):
self.assertTrue(
all(obj.number < 0 for obj in model.new_manager.negative()))
def test__get_all_related_objects__method(self):
data = (
dict(
model=get_model('myapp', 'Model1'),
field_names=('model2', ),
),
dict(
model=get_model('myapp', 'Model2'),
field_names=(),
),
dict(
model=get_model('myapp', 'Model3'),
field_names=(),
),
)
for test_data in data:
model = test_data['model']
field_names = test_data['field_names']
opts = ModelOptions(model)
related_objects = opts.get_all_related_objects()
self.assertEqual(len(related_objects), len(field_names),
(model, related_objects, field_names))
self.assertEqual(
set(field_names),
set(related_object.model_name
for related_object in related_objects),
(model, related_objects, field_names))
self.assertTrue(
all(isinstance(ro, RelatedObject) for ro in related_objects))
if related_objects:
repr(related_objects[0])
model = get_model('myapp', 'Model1')
with self.assertRaises(FieldDoesNotExist):
ModelOptions(model).get_field('model2')
def test__get_m2m_with_model__method(self):
data = (dict(
model=get_model('myapp', 'Model3'),
m2m_fields=('m2m_field', ),
), )
for test_data in data:
model = test_data['model']
m2m_fields = test_data['m2m_fields']
opts = ModelOptions(model)
for f, _ in opts.get_m2m_with_model():
# pylint: disable=protected-access
self.assertIsInstance(f, models.ManyToManyField)
self.assertIn(f.name, m2m_fields)
self.assertIs(f, model._meta.get_field(f.name))
def test_get_user_model(self):
u"""Проверка функции get_user_model."""
user_model = get_model(*AUTH_USER_MODEL.split('.'))
self.assertIs(user_model, get_user_model())
def _allow(self, db, app_label, model_name):
return (db == DEFAULT_DB_ALIAS
and get_model(app_label, model_name) is get_user_model())