gistfile1.txt

============================= test session starts ==============================
platform linux2 -- Python 2.6.6 -- pytest-2.3.5 -- /deploy/nav-mirror/.env/bin/python
plugins: django, cov
collecting ... collected 1 items

integration/models/model_test.py:41: test_models['django.contrib.sessions.models.Session seems up to date'] FAILED

=================================== FAILURES ===================================
____ test_models['django.contrib.sessions.models.Session seems up to date'] ____

model = <class 'django.contrib.sessions.models.Session'>

    def check_model(model):
    
        connection.close() # Ensure clean connection
>       list(model.objects.all()[:5])

integration/models/model_test.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = []

    def __len__(self):
        # Since __len__ is called quite frequently (for example, as part of
        # list(qs), we make some effort here to be as efficient as possible
        # whilst not messing up any existing iterators against the QuerySet.
        if self._result_cache is None:
            if self._iter:
                self._result_cache = list(self._iter)
            else:
                self._result_cache = list(self.iterator())
        elif self._iter:
>           self._result_cache.extend(self._iter)

/deploy/nav-mirror/.env/lib/python2.6/site-packages/django/db/models/query.py:87: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = []

    def iterator(self):
        """
            An iterator over the results from applying this QuerySet to the
            database.
            """
        fill_cache = False
        if connections[self.db].features.supports_select_related:
            fill_cache = self.query.select_related
        if isinstance(fill_cache, dict):
            requested = fill_cache
        else:
            requested = None
        max_depth = self.query.max_depth
    
        extra_select = self.query.extra_select.keys()
        aggregate_select = self.query.aggregate_select.keys()
    
        only_load = self.query.get_loaded_field_names()
        if not fill_cache:
            fields = self.model._meta.fields
    
        load_fields = []
        # If only/defer clauses have been specified,
        # build the list of fields that are to be loaded.
        if only_load:
            for field, model in self.model._meta.get_fields_with_model():
                if model is None:
                    model = self.model
                try:
                    if field.name in only_load[model]:
                        # Add a field that has been explicitly included
                        load_fields.append(field.name)
                except KeyError:
                    # Model wasn't explicitly listed in the only_load table
                    # Therefore, we need to load all fields from this model
                    load_fields.append(field.name)
    
        index_start = len(extra_select)
        aggregate_start = index_start + len(load_fields or self.model._meta.fields)
    
        skip = None
        if load_fields and not fill_cache:
            # Some fields have been deferred, so we have to initialise
            # via keyword arguments.
            skip = set()
            init_list = []
            for field in fields:
                if field.name not in load_fields:
                    skip.add(field.attname)
                else:
                    init_list.append(field.attname)
            model_cls = deferred_class_factory(self.model, skip)
    
        # Cache db and model outside the loop
        db = self.db
        model = self.model
        compiler = self.query.get_compiler(using=db)
        if fill_cache:
            klass_info = get_klass_info(model, max_depth=max_depth,
                                        requested=requested, only_load=only_load)
>       for row in compiler.results_iter():
            if fill_cache:

/deploy/nav-mirror/.env/lib/python2.6/site-packages/django/db/models/query.py:291: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <django.db.models.sql.compiler.SQLCompiler object at 0x2c33550>

    def results_iter(self):
        """
            Returns an iterator over the results from executing this query.
            """
        resolve_columns = hasattr(self, 'resolve_columns')
        fields = None
        has_aggregate_select = bool(self.query.aggregate_select)
        # Set transaction dirty if we're using SELECT FOR UPDATE to ensure
        # a subsequent commit/rollback is executed, so any database locks
        # are released.
        if self.query.select_for_update and transaction.is_managed(self.using):
            transaction.set_dirty(self.using)
>       for rows in self.execute_sql(MULTI):
            for row in rows:
                if resolve_columns:

/deploy/nav-mirror/.env/lib/python2.6/site-packages/django/db/models/sql/compiler.py:763: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <django.db.models.sql.compiler.SQLCompiler object at 0x2c33550>
result_type = 'multi'

    def execute_sql(self, result_type=MULTI):
        """
            Run the query against the database and returns the result(s). The
            return value is a single data item if result_type is SINGLE, or an
            iterator over the results if the result_type is MULTI.
    
            result_type is either MULTI (use fetchmany() to retrieve all rows),
            SINGLE (only retrieve a single row), or None. In this last case, the
            cursor is returned if any query is executed, since it's used by
            subclasses such as InsertQuery). It's possible, however, that no query
            is needed, as the filters describe an empty set. In that case, None is
            returned, to avoid any unnecessary database interaction.
            """
        try:
            sql, params = self.as_sql()
            if not sql:
                raise EmptyResultSet
        except EmptyResultSet:
            if result_type == MULTI:
                return empty_iter()
            else:
                return
    
>       cursor = self.connection.cursor()

/deploy/nav-mirror/.env/lib/python2.6/site-packages/django/db/models/sql/compiler.py:817: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <django.db.backends.postgresql_psycopg2.base.DatabaseWrapper object at 0x21d7d10>

    def cursor(self):
        self.validate_thread_sharing()
        if (self.use_debug_cursor or
            (self.use_debug_cursor is None and settings.DEBUG)):
            cursor = self.make_debug_cursor(self._cursor())
        else:
>           cursor = util.CursorWrapper(self._cursor(), self)
E           Failed: Database access not allowed, use the "django_db" mark to enable

/deploy/nav-mirror/.env/lib/python2.6/site-packages/django/db/backends/__init__.py:319: Failed
------------------------------- Captured stderr --------------------------------
/deploy/nav-mirror/.env/lib/python2.6/site-packages/django/core/cache/__init__.py:82: DeprecationWarning: settings.CACHE_* is deprecated; use settings.CACHES instead.
  DeprecationWarning
=========================== 1 failed in 0.67 seconds ===========================