Merge pull request mixcloud#86 from theospears/merge_on_login

matclayton · matclayton · commit 846f096c6944 · 2012-11-20T14:14:55.000-08:00
Merge experiment users on login
diff --git a/experiments/__init__.py b/experiments/__init__.py
@@ -1 +1,6 @@
+from django.contrib.auth.signals import user_logged_in
+from experiments.signals import transfer_enrollments_to_user
+
 from experiments.utils import _record_goal as record_goal
+
+user_logged_in.connect(transfer_enrollments_to_user, dispatch_uid="experiments_user_logged_in")
diff --git a/experiments/counters.py b/experiments/counters.py
@@ -13,20 +13,33 @@
 COUNTER_CACHE_KEY = 'experiments:participants:%s'
 COUNTER_FREQ_CACHE_KEY = 'experiments:freq:%s'
 
-def increment(key, participant_identifier):
+def increment(key, participant_identifier, count=1):
+    if count == 0:
+        return
+
     try:
         cache_key = COUNTER_CACHE_KEY % key
         freq_cache_key = COUNTER_FREQ_CACHE_KEY % key
-        new_value = r.hincrby(cache_key, participant_identifier, 1)
+        new_value = r.hincrby(cache_key, participant_identifier, count)
 
         # Maintain histogram of per-user counts
-        if new_value > 1:
-            r.hincrby(freq_cache_key, new_value - 1, -1)
+        if new_value > count:
+            r.hincrby(freq_cache_key, new_value - count, -1)
         r.hincrby(freq_cache_key, new_value, 1)
     except (ConnectionError, ResponseError):
         # Handle Redis failures gracefully
         pass
 
+def clear(key, participant_identifier):
+    # Remove the direct entry
+    cache_key = COUNTER_CACHE_KEY % key
+    pipe = r.pipeline()
+    freq, _ = pipe.hget(key, participant_identifier).hdel(cache_key, participant_identifier).execute()
+
+    # Remove from the histogram
+    freq_cache_key = COUNTER_FREQ_CACHE_KEY % key
+    r.hincrby(freq_cache_key, freq, -1)
+
 def get(key):
     try:
         cache_key = COUNTER_CACHE_KEY % key
@@ -35,6 +48,14 @@ def get(key):
         # Handle Redis failures gracefully
         return 0
 
+def get_frequency(key, participant_identifier):
+    try:
+        cache_key = COUNTER_CACHE_KEY % key
+        freq = r.hget(cache_key, participant_identifier)
+        return int(freq) if freq else 0
+    except (ConnectionError, ResponseError):
+        # Handle Redis failures gracefully
+        return 0
 
 def get_frequencies(key):
     try:
diff --git a/experiments/models.py b/experiments/models.py
@@ -84,17 +84,33 @@ def increment_participant_count(self, alternative_name, participant_identifier):
         counter_key = PARTICIPANT_KEY % (self.name, alternative_name)
         counters.increment(counter_key, participant_identifier)
 
-    def increment_goal_count(self, alternative_name, goal_name, participant_identifier):
+    def increment_goal_count(self, alternative_name, goal_name, participant_identifier, count=1):
         # Increment experiment_name:alternative:participant counter
         counter_key = GOAL_KEY % (self.name, alternative_name, goal_name)
-        counters.increment(counter_key, participant_identifier)
+        counters.increment(counter_key, participant_identifier, count)
+
+    def remove_participant(self, alternative_name, participant_identifier):
+        # Remove participation record
+        counter_key = PARTICIPANT_KEY % (self.name, alternative_name)
+        counters.clear(counter_key, participant_identifier)
+
+        # Remove goal records
+        goal_names = getattr(settings, 'EXPERIMENTS_GOALS', [])
+        for goal_name in goal_names:
+            counter_key = GOAL_KEY % (self.name, alternative_name, goal_name)
+            counters.clear(counter_key, participant_identifier)
 
     def participant_count(self, alternative):
         return counters.get(PARTICIPANT_KEY % (self.name, alternative))
 
     def goal_count(self, alternative, goal):
         return counters.get(GOAL_KEY % (self.name, alternative, goal))
 
+    def participant_goal_frequencies(self, alternative, participant_identifier):
+        goal_names = getattr(settings, 'EXPERIMENTS_GOALS', [])
+        for goal in goal_names:
+            yield goal, counters.get_frequency(GOAL_KEY % (self.name, alternative, goal), participant_identifier)
+
     def goal_distribution(self, alternative, goal):
         return counters.get_frequencies(GOAL_KEY % (self.name, alternative, goal))
 
diff --git a/experiments/signals.py b/experiments/signals.py
@@ -0,0 +1,8 @@
+from __future__ import absolute_import
+
+from experiments.utils import create_user
+
+def transfer_enrollments_to_user(sender, request, user, **kwargs):
+    anon_user = create_user(session=request.session)
+    authenticated_user = create_user(user=user)
+    authenticated_user.incorporate(anon_user)
diff --git a/experiments/tests/__init__.py b/experiments/tests/__init__.py
@@ -0,0 +1,10 @@
+from __future__ import absolute_import
+
+from .stats import StatsTestCase
+from .mannwhitney import MannWhitneyTestCase
+from .counter import CounterTestCase
+from .webuser import WebUserAnonymousTestCase, WebUserAuthenticatedTestCase, BotTestCase
+from . import webuser_incorporate
+
+def load_tests(*args, **kwargs):
+    return webuser_incorporate.load_tests(*args, **kwargs)
diff --git a/experiments/tests/counter.py b/experiments/tests/counter.py
@@ -0,0 +1,49 @@
+from __future__ import absolute_import
+
+from django.utils.unittest import TestCase
+
+from experiments import counters
+
+TEST_KEY = 'CounterTestCase'
+
+class CounterTestCase(TestCase):
+    def setUp(self):
+        counters.reset(TEST_KEY)
+        self.assertEqual(counters.get(TEST_KEY), 0)
+
+    def tearDown(self):
+        counters.reset(TEST_KEY)
+
+    def test_add_item(self):
+        counters.increment(TEST_KEY, 'fred')
+        self.assertEqual(counters.get(TEST_KEY), 1)
+
+    def test_add_multiple_items(self):
+        counters.increment(TEST_KEY, 'fred')
+        counters.increment(TEST_KEY, 'barney')
+        counters.increment(TEST_KEY, 'george')
+        counters.increment(TEST_KEY, 'george')
+        self.assertEqual(counters.get(TEST_KEY), 3)
+
+    def test_add_duplicate_item(self):
+        counters.increment(TEST_KEY, 'fred')
+        counters.increment(TEST_KEY, 'fred')
+        counters.increment(TEST_KEY, 'fred')
+        self.assertEqual(counters.get(TEST_KEY), 1)
+
+    def test_get_frequencies(self):
+        counters.increment(TEST_KEY, 'fred')
+        counters.increment(TEST_KEY, 'barney')
+        counters.increment(TEST_KEY, 'george')
+        counters.increment(TEST_KEY, 'roger')
+        counters.increment(TEST_KEY, 'roger')
+        counters.increment(TEST_KEY, 'roger')
+        counters.increment(TEST_KEY, 'roger')
+        self.assertEqual(counters.get_frequencies(TEST_KEY), {1: 3, 4: 1})
+
+
+    def test_delete_key(self):
+        counters.increment(TEST_KEY, 'fred')
+        counters.reset(TEST_KEY)
+        self.assertEqual(counters.get(TEST_KEY), 0)
+
diff --git a/experiments/tests/mannwhitney.py b/experiments/tests/mannwhitney.py
@@ -0,0 +1,39 @@
+from django.utils.unittest import TestCase
+
+from scipy.stats import mannwhitneyu as scipy_mann_whitney
+from experiments.significance import mann_whitney
+
+class MannWhitneyTestCase(TestCase):
+    def frequencies_to_list(self, frequencies):
+        entries = []
+        for entry,count in frequencies.items():
+            entries.extend([entry] * count)
+        return entries
+
+    def test_empty_sets(self):
+        mann_whitney(dict(), dict())
+
+    def test_identical_ranges(self):
+        distribution = dict((x,1) for x in range(50))
+        self.assertMatchesSciPy(distribution, distribution)
+
+    def test_many_repeated_values(self):
+        self.assertMatchesSciPy({0: 100, 1: 50}, {0: 110, 1: 60})
+
+    def test_large_range(self):
+        distribution_a = dict((x,1) for x in range(10000))
+        distribution_b = dict((x+1,1) for x in range(10000))
+        self.assertMatchesSciPy(distribution_a, distribution_b)
+
+    def test_very_different_sizes(self):
+        distribution_a = dict((x,1) for x in range(10000))
+        distribution_b = dict((x,1) for x in range(20))
+        self.assertMatchesSciPy(distribution_a, distribution_b)
+
+    def assertMatchesSciPy(self, distribution_a, distribution_b):
+        our_u, our_p = mann_whitney(distribution_a, distribution_b)
+        correct_u, correct_p = scipy_mann_whitney(
+            self.frequencies_to_list(distribution_a),
+            self.frequencies_to_list(distribution_b))
+        self.assertEqual(our_u, correct_u, "U score incorrect")
+        self.assertAlmostEqual(our_p, correct_p, msg="p value incorrect")
diff --git a/experiments/tests/stats.py b/experiments/tests/stats.py
@@ -0,0 +1,10 @@
+from django.utils.unittest import TestCase
+
+from experiments import stats
+
+class StatsTestCase(TestCase):
+    def test_flatten(self):
+        self.assertEqual(
+            list(stats.flatten([1,[2,[3]],4,5])),
+            [1,2,3,4,5]
+            )
diff --git a/experiments/tests/webuser.py b/experiments/tests/webuser.py
@@ -1,109 +1,17 @@
 from __future__ import absolute_import
 
-from django.utils.unittest import TestCase
+from django.test import TestCase
 from django.test.client import RequestFactory
 from django.contrib.auth.models import User, AnonymousUser
 from django.contrib.sessions.backends.db import SessionStore as DatabaseSession
 
-from experiments import stats, counters
-from experiments.utils import create_user
 from experiments.models import Experiment, ENABLED_STATE, CONTROL_GROUP
-from experiments.significance import mann_whitney
-
-from scipy.stats import mannwhitneyu as scipy_mann_whitney
+from experiments.utils import create_user
 
 request_factory = RequestFactory()
-TEST_KEY = 'CounterTestCase'
 TEST_ALTERNATIVE = 'blue'
 TEST_GOAL = 'buy'
 
-class StatsTestCase(TestCase):
-    def test_flatten(self):
-        self.assertEqual(
-            list(stats.flatten([1,[2,[3]],4,5])),
-            [1,2,3,4,5]
-            )
-
-
-class MannWhitneyTestCase(TestCase):
-    def frequencies_to_list(self, frequencies):
-        entries = []
-        for entry,count in frequencies.items():
-            entries.extend([entry] * count)
-        return entries
-
-    def test_empty_sets(self):
-        mann_whitney(dict(), dict())
-
-    def test_identical_ranges(self):
-        distribution = dict((x,1) for x in range(50))
-        self.assertMatchesSciPy(distribution, distribution)
-
-    def test_many_repeated_values(self):
-        self.assertMatchesSciPy({0: 100, 1: 50}, {0: 110, 1: 60})
-
-    def test_large_range(self):
-        distribution_a = dict((x,1) for x in range(10000))
-        distribution_b = dict((x+1,1) for x in range(10000))
-        self.assertMatchesSciPy(distribution_a, distribution_b)
-
-    def test_very_different_sizes(self):
-        distribution_a = dict((x,1) for x in range(10000))
-        distribution_b = dict((x,1) for x in range(20))
-        self.assertMatchesSciPy(distribution_a, distribution_b)
-
-    def assertMatchesSciPy(self, distribution_a, distribution_b):
-        our_u, our_p = mann_whitney(distribution_a, distribution_b)
-        correct_u, correct_p = scipy_mann_whitney(
-            self.frequencies_to_list(distribution_a),
-            self.frequencies_to_list(distribution_b))
-        self.assertEqual(our_u, correct_u, "U score incorrect")
-        self.assertAlmostEqual(our_p, correct_p, msg="p value incorrect")
-
-
-class CounterTestCase(TestCase):
-    def setUp(self):
-        counters.reset(TEST_KEY)
-        self.assertEqual(counters.get(TEST_KEY), 0)
-
-    def tearDown(self):
-        counters.reset(TEST_KEY)
-
-    def test_add_item(self):
-        counters.increment(TEST_KEY, 'fred')
-        self.assertEqual(counters.get(TEST_KEY), 1)
-
-    def test_add_multiple_items(self):
-        counters.increment(TEST_KEY, 'fred')
-        counters.increment(TEST_KEY, 'barney')
-        counters.increment(TEST_KEY, 'george')
-        counters.increment(TEST_KEY, 'george')
-        self.assertEqual(counters.get(TEST_KEY), 3)
-
-    def test_add_duplicate_item(self):
-        counters.increment(TEST_KEY, 'fred')
-        counters.increment(TEST_KEY, 'fred')
-        counters.increment(TEST_KEY, 'fred')
-        self.assertEqual(counters.get(TEST_KEY), 1)
-
-    def test_get_frequencies(self):
-        counters.increment(TEST_KEY, 'fred')
-        counters.increment(TEST_KEY, 'barney')
-        counters.increment(TEST_KEY, 'george')
-        counters.increment(TEST_KEY, 'roger')
-        counters.increment(TEST_KEY, 'roger')
-        counters.increment(TEST_KEY, 'roger')
-        counters.increment(TEST_KEY, 'roger')
-        self.assertEqual(counters.get_frequencies(TEST_KEY), {1: 3, 4: 1})
-
-
-    def test_delete_key(self):
-        counters.increment(TEST_KEY, 'fred')
-        counters.reset(TEST_KEY)
-        self.assertEqual(counters.get(TEST_KEY), 0)
-
-
-
 class WebUserTests:
     def setUp(self):
         self.experiment = Experiment(name='backgroundcolor', state=ENABLED_STATE)
@@ -182,10 +90,6 @@ def setUp(self):
         self.request.user = User(username='brian')
         self.request.user.save()
 
-    def tearDown(self):
-        self.request.user.delete()
-        super(WebUserAuthenticatedTestCase, self).tearDown()
-
 
 class BotTestCase(TestCase):
     def setUp(self):
@@ -201,7 +105,7 @@ def test_user_does_not_enroll(self):
     def test_bot_in_control_group(self):
         experiment_user = create_user(self.request)
         experiment_user.set_enrollment(self.experiment, TEST_ALTERNATIVE)
-        self.assertEqual(experiment_user.get_enrollment(self.experiment), CONTROL_GROUP, "Bot alternative is not control")
+        self.assertEqual(experiment_user.get_enrollment(self.experiment), None, "Bot enrolled in a group")
         self.assertEqual(experiment_user.is_enrolled(self.experiment.name, TEST_ALTERNATIVE, self.request), False, "Bot in test alternative")
         self.assertEqual(experiment_user.is_enrolled(self.experiment.name, CONTROL_GROUP, self.request), True, "Bot not in control group")
 
diff --git a/experiments/tests/webuser_incorporate.py b/experiments/tests/webuser_incorporate.py
diff --git a/experiments/utils.py b/experiments/utils.py
