def test_zero(self):
qs = QuerySet(X)
qs._execute = lambda: (iter([]), {})
assert_raises(X.DoesNotExist, qs.get)
ok_(not qs.exists())
eq_(qs.count(), 0)
eq_(list(qs), [])
def test_two(self):
x1 = X()
x2 = X()
qs = QuerySet(X)
qs._execute = lambda: (iter([0, 1]), {0: x1, 1: x2})
assert_raises(X.MultipleObjectsReturned, qs.get)
ok_(qs.exists())
eq_(qs.count(), 2)
eq_(list(qs), [x1, x2])
def test_repr(self):
qs = QuerySet(X)
qs.REPR_MAXLEN = 2
for repr_ in ['[]', '[x]', '[x, x]', '[x, ...]']:
eq_(repr(qs), repr_)
X.create()
qs.REPR_MAXLEN = 3
eq_(repr(qs), '[x, x, ...]')
qs.REPR_MAXLEN = 4
eq_(repr(qs), '[x, x, x, x]')
def test_execute(self, MockCache):
obj_cache = Mock(pks=[1, 2, 3, 4])
MockCache.return_value = obj_cache
qs = QuerySet(X)
qs.query = MagicMock()
qs.query.__and__.return_value = qs.query
qs.query.execute.return_value = [1, 2, 3]
eq_(qs._execute(a=1, b=2), ([1, 2, 3], obj_cache))
qs.query.__and__.assert_called_once_with(Q(a=1, b=2))
qs.query.execute.assert_called_once_with(obj_cache, obj_cache.pks)
def __new__(cls, cls_name, bases, attrs):
super_new = super().__new__
parents = [b for b in bases if isinstance(b, ModelBase)]
if not parents:
return super_new(cls, cls_name, bases, attrs)
module = attrs.pop('__module__')
new_class = super_new(cls, cls_name, bases, {'__module__': module})
opts = Options(attrs.pop('Meta', None))
new_class.add_to_class('_meta', opts)
objects = attrs.pop('objects', None)
if objects is None:
objects = QuerySet(new_class)
new_class.add_to_class('objects', objects)
for exc_class in MODEL_EXCEPTIONS:
name = exc_class.__name__
exc_class = type(name, (exc_class, ), {'__module__': module})
new_class.add_to_class(name, exc_class)
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj)
opts._prepare()
return new_class
def test_eq(self):
qs = QuerySet(X)
eq_(qs, qs)
eq_(qs, QuerySet(X))
eq_(qs, qs.all())
eq_(qs, qs.filter())
eq_(qs.filter(), qs.all())
def test_one(self):
x = X()
qs = QuerySet(X)
qs._execute = lambda: (iter([0]), {0: x})
eq_(qs.get(), x)
ok_(qs.exists())
eq_(qs.count(), 1)
eq_(list(qs), [x])
def test_eq_somthing_else(self):
assert_not_equal(QuerySet(X), None)
assert_not_equal(QuerySet(X), 'unicode-cat')
assert_not_equal(QuerySet(X), X)
def exclude_slice(self):
eq_(QuerySet(X).exclude(a=1)[:3].query, ~Q(a=1)[:3])
def exclude(self, *args, **kwargs):
return QuerySet(X).exclude(*args, **kwargs).query
def test_all(self):
eq_(QuerySet(X).all().query, Q())
def test_invert(self):
qs = QuerySet(X)
eq_(~qs.filter(a=1).query, ~Q(a=1))
def test_or(self):
qs = QuerySet(X)
eq_((qs.filter(a=1) | qs.filter(b=2)).query, Q(a=1) | Q(b=2))
def slice_exclude(self):
eq_(QuerySet(X)[:3].exclude(a=1).query, Q()[:3] & ~Q(a=1))
def slice_filter(self):
eq_(QuerySet(X)[:3].filter(a=1).query, Q()[:3] & Q(a=1))
def order_by_slice(self):
eq_(QuerySet(X).order_by('a')[:3].query, Q().order_by('a')[:3])
def exclude_filter(self):
eq_(QuerySet(X).exclude(a=1).filter(b=2).query, ~Q(a=1) & Q(b=2))
def order_by_exclude(self):
eq_(QuerySet(X).order_by('a').exclude(b=2).query,
Q().order_by('a') & ~Q(b=2))
def order_by_filter(self):
eq_(QuerySet(X).order_by('a').filter(b=2).query,
Q().order_by('a') & Q(b=2))
def test_eq_other_model(self):
class Y(models.Model): pass
assert_not_equal(QuerySet(X), QuerySet(Y))
def test_eq_other_query(self):
assert_not_equal(QuerySet(X), QuerySet(X).filter(title='foo'))
def slice_order_by(self):
eq_(QuerySet(X)[:3].order_by('a').query, Q()[:3].order_by('a'))
def test_and(self):
qs = QuerySet(X)
eq_((qs.filter(a=1) & qs.filter(b=2)).query, Q(a=1, b=2))
def filter_slice(self):
eq_(QuerySet(X).filter(a=1)[:3].query, Q(a=1)[:3])
def test_slice(self):
qs = QuerySet(X)
eq_(qs[:3].query, Q()[:3])
def filter_exclude(self):
eq_(QuerySet(X).filter(a=1).exclude(b=2).query, Q(a=1) & ~Q(b=2))
def filter(self, *args, **kwargs):
return QuerySet(X).filter(*args, **kwargs).query
def filter_order_by(self):
eq_(QuerySet(X).filter(a=1).order_by('b').query, Q(a=1).order_by('b'))
def __new__(cls, cls_name, bases, attrs):
super_new = super().__new__
parents = [b for b in bases if isinstance(b, ModelBase)]
if not parents:
return super_new(cls, cls_name, bases, attrs)
module = attrs.pop('__module__')
#new_class = super_new(cls, cls_name, bases, {'__module__': module})
new_attrs = {'__module__': module}
classcell = attrs.pop('__classcell__', None)
if classcell is not None:
new_attrs['__classcell__'] = classcell
new_class = super_new(cls, cls_name, bases, new_attrs)
meta = attrs.pop('Meta', None)
app_label = None
app_config = apps.get_containing_app_config(module)
if getattr(meta, 'app_label', None) is None:
if app_config is None:
raise RuntimeError(
"Model class %s.%s doesn't declare an explicit "
"app_label and isn't in an application in "
"INSTALLED_APPS." % (module, cls_name))
else:
app_label = app_config.label
opts = Options(meta, app_label)
new_class.add_to_class('_meta', opts)
objects = attrs.pop('objects', None)
if objects is None:
objects = QuerySet(new_class)
for base in bases:
if not hasattr(base, '_meta'):
continue
if base._meta.has_custom_queryset:
objects = base.objects._copy_to_model(cls)
new_class._meta.has_custom_queryset = True
# TODO: Should we break here?
else:
new_class._meta.has_custom_queryset = True
new_class.add_to_class('objects', objects)
for name, exc_class in MODEL_EXCEPTIONS:
exc_class = type(name, (exc_class, ), {'__module__': module})
new_class.add_to_class(name, exc_class)
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj)
field_names = [f.name for f in new_class._meta.fields]
for base in parents:
if not hasattr(base, '_meta'):
# Things without _meta aren't functional models, so they're
# uninteresting parents.
continue
parent_fields = base._meta.fields
# Check for clashes between locally declared fields and those
# on the base classes (we cannot handle shadowed fields at the
# moment).
for field in parent_fields:
if field.name in field_names:
raise FieldError('Local field %r in class %r clashes '
'with field of similar name from '
'base class %r' %
(field.name, cls_name, base.__name__))
for field in parent_fields:
if field.primary_key and field.auto_created:
continue
new_field = copy.deepcopy(field)
new_class.add_to_class(field.name, new_field)
new_class._meta.concrete_model = new_class
opts._prepare()
new_class._meta.apps.register_model(new_class._meta.app_label,
new_class)
return new_class
def exclude_order_by(self):
eq_(QuerySet(X).exclude(a=1).order_by('b').query, ~Q(a=1).order_by('b'))
