Be sure that LAST_SEEN_INTERVAL is used.

LAST_SEEN_INTERVAL must be used independently of the cache timeout and
independetly of if there is any cache.

Solves #1

Author: ferranp

last_seen/models.py

@@ -1,4 +1,5 @@
 import time
+import datetime
 from django.db import models
 from django.contrib.sites.models import Site
 from django.utils import timezone
@@ -13,12 +14,16 @@ class LastSeenManager(models.Manager):
 
         Provides 2 utility methods
     """
-    def seen(self, user, module=settings.LAST_SEEN_DEFAULT_MODULE, site=None):
+    def seen(self, user, module=settings.LAST_SEEN_DEFAULT_MODULE, site=None,
+                force=False):
         """
             Mask an user last on database seen with optional module and site
 
             If module not provided uses LAST_SEEN_DEFAULT_MODULE from settings
             If site not provided uses current site
+
+            The last seen object is only updates is LAST_SEEN_INTERVAL seconds
+            passed from last update or force=True
         """
         if not site:
             site = Site.objects.get_current()
@@ -27,9 +32,18 @@ def seen(self, user, module=settings.LAST_SEEN_DEFAULT_MODULE, site=None):
             'site': site,
             'module': module,
         }
-        updated = self.filter(**args).update(last_seen=timezone.now())
-        if not updated:
-            self.create(**args)
+        seen, created = self.get_or_create(**args)
+        if created:
+            return seen
+
+        # if we get the object, see if we need to update
+        limit = timezone.now() - \
+            datetime.timedelta(seconds=settings.LAST_SEEN_INTERVAL)
+        if seen.last_seen < limit or force:
+            seen.last_seen = timezone.now()
+            seen.save()
+
+        return seen
 
     def when(self, user, module=None, site=None):
         args = {'user': user}
@@ -81,9 +95,14 @@ def user_seen(user, module=settings.LAST_SEEN_DEFAULT_MODULE, site=None):
     limit = time.time() - settings.LAST_SEEN_INTERVAL
     seen = cache.get(cache_key)
     if not seen or seen < limit:
-        # mark the database and the cache
-        LastSeen.objects.seen(user, module=module, site=site)
-        cache.set(cache_key, time.time())
+        # mark the database and the cache, if interval is cleared force
+        # database write
+        if seen == -1:
+            LastSeen.objects.seen(user, module=module, site=site, force=True)
+        else:
+            LastSeen.objects.seen(user, module=module, site=site)
+        timeout = settings.LAST_SEEN_INTERVAL
+        cache.set(cache_key, time.time(), timeout)
 
 
 def clear_interval(user):
@@ -92,10 +111,10 @@ def clear_interval(user):
 
         Usefuf if you want to force a database write for an user
     """
-    keys = []
+    keys = {}
     for last_seen in LastSeen.objects.filter(user=user):
         cache_key = get_cache_key(last_seen.site, last_seen.module, user)
-        keys.append(cache_key)
+        keys[cache_key] = -1
 
     if keys:
-        cache.delete_many(keys)
+        cache.set_many(keys)

last_seen/tests.py

@@ -5,6 +5,7 @@
 from django.contrib.auth.models import User
 from django.contrib.sites.models import Site
 from django.core.cache import cache
+from django.utils import timezone
 
 from last_seen.models import LastSeen, user_seen, clear_interval
 from last_seen import settings
@@ -23,45 +24,99 @@ def test_unicode(self):
 
 class TestLastSeenManager(TestCase):
 
-    @mock.patch('last_seen.models.LastSeen.objects.create', autospec=True)
-    @mock.patch('last_seen.models.LastSeen.objects.filter', autospec=True)
-    def test_seen(self, filter, create):
-        user = User(username='testuser')
-        filter.return_value.update.return_value = 1
+    @mock.patch('last_seen.models.LastSeen.objects.get_or_create',
+                                                            autospec=True)
+    def test_seen(self, get_or_create):
+        user = User(username='testuser', pk=1)
+        lastseen = mock.Mock(LastSeen)
+        get_or_create.return_value = (lastseen, True)
 
         LastSeen.objects.seen(user=user)
 
-        filter.assert_called_with(user=user,
+        get_or_create.assert_called_with(user=user,
                 module=settings.LAST_SEEN_DEFAULT_MODULE,
                 site=Site.objects.get_current())
-        self.assertFalse(create.called)
+        self.assertFalse(lastseen.save.called)
 
-    @mock.patch('last_seen.models.LastSeen.objects.create', autospec=True)
-    @mock.patch('last_seen.models.LastSeen.objects.filter', autospec=True)
-    def test_seen_no_default(self, filter, create):
-        user = User(username='testuser')
+    @mock.patch('last_seen.models.LastSeen.objects.get_or_create',
+                                                            autospec=True)
+    def test_seen_no_default(self, get_or_create):
+        user = User(username='testuser', pk=1)
         site = Site(pk=2)
-        filter.return_value.update.return_value = 1
+        get_or_create.return_value = (None, True)
 
         LastSeen.objects.seen(user=user, site=site, module="test")
 
-        filter.assert_called_with(user=user, module="test", site=site)
-        self.assertFalse(create.called)
+        get_or_create.assert_called_with(user=user, module="test", site=site)
 
-    @mock.patch('last_seen.models.LastSeen.objects.create', autospec=True)
-    @mock.patch('last_seen.models.LastSeen.objects.filter', autospec=True)
-    def test_seen_create(self, filter, create):
+    @mock.patch('last_seen.models.LastSeen.objects.get_or_create',
+                                                            autospec=True)
+    def test_seen_create(self, get_or_create):
         user = User(username='testuser')
-        filter.return_value.update.return_value = 0
+        lastseen = mock.Mock(LastSeen)
+        get_or_create.return_value = (lastseen, True)
 
         LastSeen.objects.seen(user=user)
 
-        filter.assert_called_with(user=user,
+        get_or_create.assert_called_with(user=user,
+                module=settings.LAST_SEEN_DEFAULT_MODULE,
+                site=Site.objects.get_current())
+        self.assertFalse(lastseen.save.called)
+
+    @mock.patch('last_seen.models.LastSeen.objects.get_or_create',
+                                                            autospec=True)
+    def test_seen_update(self, get_or_create):
+        user = User(username='testuser')
+        lastseen = mock.Mock(LastSeen)
+        # force last seen old
+        old_time = timezone.now() - \
+                datetime.timedelta(seconds=(settings.LAST_SEEN_INTERVAL * 2))
+        lastseen.last_seen = old_time
+        get_or_create.return_value = (lastseen, False)
+
+        ret = LastSeen.objects.seen(user=user)
+
+        get_or_create.assert_called_with(user=user,
+                module=settings.LAST_SEEN_DEFAULT_MODULE,
+                site=Site.objects.get_current())
+        self.assertTrue(lastseen.save.called)
+        self.assertNotEqual(ret.last_seen, old_time)
+
+    @mock.patch('last_seen.models.LastSeen.objects.get_or_create',
+                                                            autospec=True)
+    def test_seen_update_forced(self, get_or_create):
+        user = User(username='testuser')
+        lastseen = mock.Mock(LastSeen)
+        # force last seen old
+        old_time = timezone.now()
+        lastseen.last_seen = old_time
+        get_or_create.return_value = (lastseen, False)
+
+        ret = LastSeen.objects.seen(user=user, force=True)
+
+        get_or_create.assert_called_with(user=user,
                 module=settings.LAST_SEEN_DEFAULT_MODULE,
                 site=Site.objects.get_current())
-        create.assert_called_with(user=user,
+        self.assertTrue(lastseen.save.called)
+        self.assertNotEqual(ret.last_seen, old_time)
+
+    @mock.patch('last_seen.models.LastSeen.objects.get_or_create',
+                                                            autospec=True)
+    def test_seen_found_not_updated(self, get_or_create):
+        user = User(username='testuser')
+        lastseen = mock.Mock(LastSeen)
+        # force last seen old
+        old_time = timezone.now()
+        lastseen.last_seen = old_time
+        get_or_create.return_value = (lastseen, False)
+
+        ret = LastSeen.objects.seen(user=user)
+
+        get_or_create.assert_called_with(user=user,
                 module=settings.LAST_SEEN_DEFAULT_MODULE,
                 site=Site.objects.get_current())
+        self.assertFalse(lastseen.save.called)
+        self.assertEqual(ret.last_seen, old_time)
 
     def test_when_non_existent(self):
         user = User(username='testuser', pk=1)
@@ -92,9 +147,13 @@ def test_seen_site(self, filter):
 
 class TestUserSeen(TestCase):
 
+    def setUp(self):
+        [cache.delete(key) for key in cache._cache.keys()]
+
     @mock.patch('last_seen.models.LastSeen.objects.seen', autospec=True)
     def test_user_seen(self, seen):
-        user = User(username='testuser', pk=1)
+        user = User(username='testuser', pk=999)
+
         user_seen(user)
         site = Site.objects.get_current()
         seen.assert_called_with(user, module=settings.LAST_SEEN_DEFAULT_MODULE,
@@ -140,8 +199,8 @@ def test_clear_interval(self, cache, filter):
         clear_interval(user)
 
         filter.assert_called_with(user=user)
-        expected = ['last_seen:1:mod1:1', 'last_seen:1:mod2:1']
-        cache.delete_many.assert_called_with(expected)
+        expected = {'last_seen:1:mod1:1': -1, 'last_seen:1:mod2:1': -1}
+        cache.set_many.assert_called_with(expected)
 
     @mock.patch('last_seen.models.LastSeen.objects.filter', autospec=True)
     @mock.patch('last_seen.models.cache', autospec=True)
@@ -154,6 +213,17 @@ def test_clear_interval_none(self, cache, filter):
         filter.assert_called_with(user=user)
         self.assertFalse(cache.delete_many.called)
 
+    def test_clear_interval_works(self):
+        user = User.objects.create(username='testuser')
+
+        user_seen(user)
+        when1 = LastSeen.objects.when(user=user)
+        clear_interval(user)
+        user_seen(user)
+        when2 = LastSeen.objects.when(user=user)
+
+        self.assertNotEqual(when1, when2)
+
 
 class TestMiddleware(TestCase):
 

test_project/settings.py

@@ -6,7 +6,7 @@
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
-        'NAME': ':memory:',                      # Or path to database file if using sqlite3.
+        'NAME': 'test.db',                      # Or path to database file if using sqlite3.
         'USER': '',                      # Not used with sqlite3.
         'PASSWORD': '',                  # Not used with sqlite3.
         'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
@@ -33,3 +33,15 @@
     'last_seen',
 )
 
+STATIC_URL = "/static/"
+
+MIDDLEWARE_CLASSES = (
+    'django.middleware.common.CommonMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.middleware.locale.LocaleMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    'last_seen.middleware.LastSeenMiddleware',
+)

test_project/urls.py

@@ -1,9 +1,18 @@
 from django.conf.urls import patterns, include, url
+from last_seen.models import clear_interval
+from django.shortcuts import redirect
 
 # Uncomment the next two lines to enable the admin:
 from django.contrib import admin
 admin.autodiscover()
 
+
+def clear(request):
+    """ Testing view to force clear interval of user"""
+    clear_interval(request.user)
+    return redirect("/admin")
+
+
 urlpatterns = patterns('',
     # Examples:
     # url(r'^$', 'test_project.views.home', name='home'),
@@ -14,4 +23,5 @@
 
     # Uncomment the next line to enable the admin:
     url(r'^admin/', include(admin.site.urls)),
+    url(r'^clear/', clear),
 )