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'))