def test_max(self):
#Tests that the max run for A/B tests is working
for i in xrange(0, 5):
self.assertTrue(flipper.is_active('max'))
LocalStoreMiddleware.local.clear()
self.assertFalse(flipper.is_active('max'))
def test_random(self, randrange):
#Tests that the random flag is working correctly
randrange.return_value = 1
self.assertTrue(flipper.is_active('ab_random'))
LocalStoreMiddleware.local.clear()
randrange.return_value = 0
self.assertFalse(flipper.is_active('ab_random'))
def test_end(self):
"""Tests that the end datetime for A/B tests is working"""
now = datetime.datetime.now()
self.backend.update('end_passed', dict(name='end_passed', enabled=True, b_test_end=now-datetime.timedelta(days=1)))
self.backend.update('end_tomorrow', dict(name='end_tomorrow', enabled=True, b_test_end=now+datetime.timedelta(days=1)))
self.assertTrue(flipper.is_active('end_tomorrow'))
self.assertFalse(flipper.is_active('end_passed'))
def test_end(self):
#Tests that the end datetime for A/B tests is working
now = datetime.datetime.now()
FeatureFlag.objects.create(name='end_passed', enabled=True, b_test_end=now-datetime.timedelta(days=1))
FeatureFlag.objects.create(name='end_tomorrow', enabled=True, b_test_end=now+datetime.timedelta(days=1))
self.assertTrue(flipper.is_active('end_tomorrow'))
self.assertFalse(flipper.is_active('end_passed'))
def test_registered(self):
#Tests the registered user only flags
req = self._fake_request()
req.user = User.objects.get(username='******')
#registered user
self.assertTrue(flipper.is_active("registered_only", request=req))
#anonymous user
req.user = AnonymousUser()
self.assertFalse(flipper.is_active("registered_only", request=req))
def test_enabled_custom_flag(self):
#base test
self.assertTrue(flipper.is_active("enabled"))
flipper.register_check('enabled', lambda x, **kwargs: True)
flipper.register_check('disabled', lambda x, **kwargs: True)
self.assertTrue(flipper.is_active('enabled'))
self.assertFalse(flipper.is_active('disabled'))
flipper.register_check('enabled', lambda x, **kwargs: False)
self.assertFalse(flipper.is_active('enabled'))
def test_cookies_being_retrieved_properly(self):
#Verify that cookies are being retrieved properly
cookie_prefix = getattr(settings, 'DOLPHIN_COOKIE', 'dolphin_%s')
cookie = cookie_prefix % 'cookie_flag'
FeatureFlag.objects.create(name='cookie_flag', enabled=True, cookie_max_age=self.one_hour_later)
req = self._fake_request()
#Cookie values are the 2nd ones checked after overrides in the is active function.
#When cookies are found in the request object, they will be used.
req.COOKIES = {cookie: False}
self.assertFalse(flipper.is_active('cookie_flag', request=req))
req.COOKIES = {cookie: True}
self.assertTrue(flipper.is_active('cookie_flag', request=req))
def test_users(self):
#Tests the user specific flags
req = self._fake_request()
user = User.objects.get(username='******')
req.user = user
self.assertTrue(flipper.is_active('selected_group', request=req))
req.user = AnonymousUser()
self.assertFalse(flipper.is_active('users', request=req))
req.user = User.objects.get(username='******')
self.assertFalse(flipper.is_active('users', request=req))
def test_random_percent(self, uniform):
#Tests that the feature is active for random percentages
req = self._fake_request()
FeatureFlag.objects.create(name='ab_percent', enabled=True, percent=50)
uniform.return_value = 1
#Need a request object to store the flag cookie
self.assertTrue(flipper.is_active('ab_percent'))
LocalStoreMiddleware.local.clear()
uniform.return_value = 51
#Need a request object to store the cookie
self.assertFalse(flipper.is_active('ab_percent'))
def test_staff(self):
#Tests the staff only flags
settings.DOLPHIN_STORE_FLAGS=False
req = self._fake_request()
req.user = User.objects.get(username='******')
#registered user
self.assertFalse(flipper.is_active("staff_only", request=req))
#anonymous user
req.user = AnonymousUser()
self.assertFalse(flipper.is_active("staff_only", request=req))
#staff user
req.user = User.objects.get(username="******")
self.assertTrue(flipper.is_active("staff_only", request=req))
def test_disable_for_site(self):
#Tests that the feature is inactive for the sites specified
site = Site.objects.get_current()
flag = FeatureFlag.objects.create(name='disabled_test', enabled=True)
# disable_for_sites without any sites should be active
flag.disable_for_sites = True
flag.save()
self.assertTrue(flipper.is_active('disabled_test'))
LocalStoreMiddleware.local.clear()
# now add the current site, it should be inactive
flag.sites.add(site)
self.assertFalse(flipper.is_active('disabled_test'))
def test_cookies_in_local_store(self):
#Verify that cookies are being stored in dolphin's local store correctly
FeatureFlag.objects.create(name='cookie_flag', enabled=True, cookie_max_age=self.one_hour_later)
cookie_prefix = getattr(settings, 'DOLPHIN_COOKIE', 'dolphin_%s')
cookie = cookie_prefix % 'cookie_flag'
is_active = flipper.is_active('cookie_flag')
self.assertEqual(LocalStoreMiddleware.local.get('dolphin_cookies')[cookie][0], is_active)
def test_create_missing(self):
settings.DOLPHIN_AUTOCREATE_MISSING = True
self.assertFalse(flipper.is_active('missing'))
backend = flipper.backend._get_backend()
val = backend.hgetall('missing')
self.assertEquals(val['enabled'], 'False')
self.assertEquals(val['name'], 'missing')
settings.DOLPHIN_AUTOCREATE_MISSING = False
def test_enable_for_sites(self):
#Tests that the feature is active for only the enabled sites
site = Site.objects.get_current()
flag = FeatureFlag.objects.create(name='enable_test', enabled=True)
# with enable_for_sites set to false it should be active
self.assertTrue(flipper.is_active('enable_test'))
LocalStoreMiddleware.local.clear()
# set enable_for_sites to true without any sites should be inactive
flag.enable_for_sites = True
flag.save()
self.assertFalse(flipper.is_active('enable_test'))
LocalStoreMiddleware.local.clear()
# now add the current site, it should be active
flag.sites.add(site)
self.assertTrue(flipper.is_active('enable_test'))
def test_random(self, randrange):
"""Tests that the random flag is working correctly"""
c = Client()
randrange.return_value = 1
resp = c.get('/flag_is_active/ab_random/')
self.assertEquals(resp.content, "True")
LocalStoreMiddleware.local.clear()
randrange.return_value = 0
self.assertFalse(flipper.is_active('ab_random'))
resp = c.get('/flag_is_active/ab_random/')
self.assertEquals(resp.content, "True")
def test_regional_flag(self):
try:
from django.contrib.gis.utils import geoip
if hasattr(geoip,'HAS_GEOIP') and not geoip.HAS_GEOIP:
return self.skipTest('GIS not installed. Skipping GeoIPTest')
except Exception:
return self.skipTest('GIS not installed. Skipping GeoIPTest')
#Tests that the regional flag works properly for IP address detection and distance
req = self._fake_request()
req.META = {'REMOTE_ADDR':'4.2.2.2'}
#within 100 miles of coord (69 or so)
self.assertTrue(flipper.is_active('regional', request=req))
req.META = {'REMOTE_ADDR':'0.0.0.0'}
self.assertFalse(flipper.is_active('regional', request=req))
req.META = {'REMOTE_ADDR':'74.125.227.39'}
#not within 100 miles of coord
self.assertFalse(flipper.is_active('regional', request=req))
req.META = {'REMOTE_ADDR':'4.2.2.2'}
#not within 5 miles of coord
self.assertFalse(flipper.is_active('regional_5', request=req))
def render(self, context):
key = self.key.resolve(context, True)
args = []
kwargs = {}
for arg in self.other_args:
#resolve other_args
arg = arg.resolve(context, True)
if '=' in arg:
k, v = arg.split('=')
kwargs[k] = v
else:
args.append(arg)
if flipper.is_active(key, *args, **kwargs):
return self.nodelist_true.render(context)
return self.nodelist_false.render(context)
def is_active(request, slug):
return HttpResponse(str(flipper.is_active(slug)))
def test_redis_fixture(self):
self.assertTrue(flipper.is_active('enabled'))
def test_is_active(self):
self.assertTrue(flipper.is_active("enabled"))
self.assertFalse(flipper.is_active("disabled"))
self.assertFalse(flipper.is_active("missing"))
def test_create_missing(self):
settings.DOLPHIN_AUTOCREATE_MISSING = True
self.assertFalse(flipper.is_active('missing'))
self.assertTrue(FeatureFlag.objects.filter(name='missing').exists())
settings.DOLPHIN_AUTOCREATE_MISSING = False
def test_0_percent(self):
#Tests that the feature is not active for when the percent value is set to 0
FeatureFlag.objects.create(name='ab_percent', enabled=True, percent=0)
self.assertFalse(flipper.is_active('ab_percent'))
def test_100_percent(self):
#Tests that the feature is active when the percent is set to 100
FeatureFlag.objects.create(name='ab_percent', enabled=True, percent=100)
self.assertTrue(flipper.is_active('ab_percent'))
def test_set_active(self):
with set_active("test_flag", True):
self.assertTrue(flipper.is_active('test_flag'))
self.assertFalse(flipper.is_active('test_flag'))
