def is_active(self, request):
if not self.pk:
if get_setting('LOG_MISSING_FLAGS'):
logger.log(level=get_setting('LOG_MISSING_FLAGS'), msg=("Flag %s not found", self.name))
if get_setting('CREATE_MISSING_FLAGS'):
get_waffle_flag_model().objects.get_or_create(
name=self.name,
defaults={
'everyone': get_setting('FLAG_DEFAULT')
}
)
return get_setting('FLAG_DEFAULT')
if get_setting('OVERRIDE'):
if self.name in request.GET:
return request.GET[self.name] == '1'
if self.everyone:
return True
elif self.everyone is False:
return False
if self.testing: # Testing mode is on.
tc = get_setting('TEST_COOKIE') % self.name
if tc in request.GET:
on = request.GET[tc] == '1'
if not hasattr(request, 'waffle_tests'):
request.waffle_tests = {}
request.waffle_tests[self.name] = on
return on
if tc in request.COOKIES:
return request.COOKIES[tc] == 'True'
active_for_language = self._is_active_for_language(request)
if active_for_language is not None:
return active_for_language
active_for_user = self._is_active_for_user(request)
if active_for_user is not None:
return active_for_user
if self.percent and self.percent > 0:
if not hasattr(request, 'waffles'):
request.waffles = {}
elif self.name in request.waffles:
return request.waffles[self.name][0]
cookie = get_setting('COOKIE') % self.name
if cookie in request.COOKIES:
flag_active = (request.COOKIES[cookie] == 'True')
set_flag(request, self.name, flag_active, self.rollout)
return flag_active
if Decimal(str(random.uniform(0, 100))) <= self.percent:
set_flag(request, self.name, True, self.rollout)
return True
set_flag(request, self.name, False, self.rollout)
return False
def test_pluggable_model(self):
flag_model = waffle.get_waffle_flag_model()
self.assertEqual(CompanyAwareFlag, flag_model)
acme_company = Company.objects.create(name='Acme Ltd.')
feline_company = Company.objects.create(name='Feline LLC')
acme_company_flag = waffle.get_waffle_flag_model().objects.create(
name='myflag', superusers=True)
acme_company_flag.companies.add(acme_company)
request = get()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
acme_user = get_user_model()(username='******',
company=acme_company)
request.user = acme_user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
assert 'dwf_myflag' not in response.cookies
feline_user = get_user_model()(username='******',
company=feline_company)
request.user = feline_user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
def test_delete_flag(self):
""" The command should delete a flag. """
name = 'test_flag'
get_waffle_flag_model().objects.create(name=name)
call_command('waffle_delete', flag_names=[name])
self.assertEqual(get_waffle_flag_model().objects.count(), 0)
def test_percent(self):
"""If you have no cookie, you get a cookie!"""
waffle.get_waffle_flag_model().objects.create(name='myflag',
percent='50.0')
request = get()
response = process_request(request, views.flag_in_view)
assert 'dwf_myflag' in response.cookies
def test_delete_flag(self):
""" The command should delete a flag. """
name = 'test_flag'
get_waffle_flag_model().objects.create(name=name)
call_command('waffle_delete', flag_names=[name])
self.assertEqual(get_waffle_flag_model().objects.count(), 0)
def test_pluggable_model(self):
flag_model = waffle.get_waffle_flag_model()
self.assertEqual(CompanyAwareFlag, flag_model)
acme_company = Company.objects.create(name='Acme Ltd.')
feline_company = Company.objects.create(name='Feline LLC')
acme_company_flag = waffle.get_waffle_flag_model().objects.create(name='myflag', superusers=True)
acme_company_flag.companies.add(acme_company)
request = get()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
acme_user = get_user_model()(username='******', company=acme_company)
request.user = acme_user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
assert 'dwf_myflag' not in response.cookies
feline_user = get_user_model()(username='******', company=feline_company)
request.user = feline_user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
def handle(self, *args, **options):
if options['list_flags']:
self.stdout.write('Flags:')
for flag in get_waffle_flag_model().objects.iterator():
self.stdout.write('NAME: %s' % flag.name)
self.stdout.write('SUPERUSERS: %s' % flag.superusers)
self.stdout.write('EVERYONE: %s' % flag.everyone)
self.stdout.write('AUTHENTICATED: %s' % flag.authenticated)
self.stdout.write('PERCENT: %s' % flag.percent)
self.stdout.write('TESTING: %s' % flag.testing)
self.stdout.write('ROLLOUT: %s' % flag.rollout)
self.stdout.write('STAFF: %s' % flag.staff)
self.stdout.write('GROUPS: %s' % list(
flag.groups.values_list('name', flat=True))
)
self.stdout.write('')
return
flag_name = options['name']
if not flag_name:
raise CommandError('You need to specify a flag name.')
if options['create']:
flag, created = get_waffle_flag_model().objects.get_or_create(name=flag_name)
if created:
self.stdout.write('Creating flag: %s' % flag_name)
else:
try:
flag = get_waffle_flag_model().objects.get(name=flag_name)
except get_waffle_flag_model().DoesNotExist:
raise CommandError('This flag does not exist.')
# Loop through all options, setting Flag attributes that
# match (ie. don't want to try setting flag.verbosity)
for option in options:
# Group isn't an attribute on the Flag, but a related Many to Many
# field, so we handle it a bit differently by looking up groups and
# adding each group to the flag individually
if option == 'group':
group_hash = {}
for group in options['group']:
try:
group_instance = Group.objects.get(name=group)
group_hash[group_instance.name] = group_instance.id
except Group.DoesNotExist:
raise CommandError('Group %s does not exist' % group)
# If 'append' was not passed, we clear related groups
if not options['append']:
flag.groups.clear()
self.stdout.write('Setting group(s): %s' % (
[name for name, _id in group_hash.items()])
)
for group_name, group_id in group_hash.items():
flag.groups.add(group_id)
elif hasattr(flag, option):
self.stdout.write('Setting %s: %s' % (option, options[option]))
setattr(flag, option, options[option])
flag.save()
def test_flag_must_be_inactive_and_redirect_to_named_view_with_args(self):
resp = self.client.get(
'/flagged_view_with_args_with_valid_url_name/1/')
self.assertRedirects(resp, '/foo_view_with_args/1/')
get_waffle_flag_model().objects.create(name='foo', everyone=True)
resp = self.client.get(
'/flagged_view_with_args_with_valid_url_name/1/')
self.assertEqual(200, resp.status_code)
def is_active(self, request):
if not self.pk:
if get_setting('LOG_MISSING_FLAGS'):
logger.log(level=get_setting('LOG_MISSING_FLAGS'),
msg=("Flag %s not found", self.name))
if get_setting('CREATE_MISSING_FLAGS'):
get_waffle_flag_model().objects.get_or_create(
name=self.name,
defaults={'everyone': get_setting('FLAG_DEFAULT')})
return get_setting('FLAG_DEFAULT')
if get_setting('OVERRIDE'):
if self.name in request.GET:
return request.GET[self.name] == '1'
if self.everyone:
return True
elif self.everyone is False:
return False
if self.testing: # Testing mode is on.
tc = get_setting('TEST_COOKIE') % self.name
if tc in request.GET:
on = request.GET[tc] == '1'
if not hasattr(request, 'waffle_tests'):
request.waffle_tests = {}
request.waffle_tests[self.name] = on
return on
if tc in request.COOKIES:
return request.COOKIES[tc] == 'True'
active_for_language = self._is_active_for_language(request)
if active_for_language is not None:
return active_for_language
active_for_user = self._is_active_for_user(request)
if active_for_user is not None:
return active_for_user
if self.percent and self.percent > 0:
if not hasattr(request, 'waffles'):
request.waffles = {}
elif self.name in request.waffles:
return request.waffles[self.name][0]
cookie = get_setting('COOKIE') % self.name
if cookie in request.COOKIES:
flag_active = (request.COOKIES[cookie] == 'True')
set_flag(request, self.name, flag_active, self.rollout)
return flag_active
if Decimal(str(random.uniform(0, 100))) <= self.percent:
set_flag(request, self.name, True, self.rollout)
return True
set_flag(request, self.name, False, self.rollout)
return False
def test_testing_disabled_flag(self):
waffle.get_waffle_flag_model().objects.create(name='foo')
request = get(dwft_foo='1')
assert not waffle.flag_is_active(request, 'foo')
assert not hasattr(request, 'waffle_tests')
request = get(dwft_foo='0')
assert not waffle.flag_is_active(request, 'foo')
assert not hasattr(request, 'waffle_tests')
def test_percent_readonly(self, uniform):
uniform.return_value = '10'
"""If you have no cookie, you do not get a cookie if we just have a question!"""
waffle.get_waffle_flag_model().objects.create(name='myflag',
percent='50.0')
request = get()
response = process_request(request, views.flag_in_view_readonly)
assert 'dwf_myflag' not in response.cookies
self.assertEqual(b'off', response.content)
def test_testing_disabled_flag(self):
waffle.get_waffle_flag_model().objects.create(name='foo')
request = get(dwft_foo='1')
assert not waffle.flag_is_active(request, 'foo')
assert not hasattr(request, 'waffle_tests')
request = get(dwft_foo='0')
assert not waffle.flag_is_active(request, 'foo')
assert not hasattr(request, 'waffle_tests')
def test_flag_existed_and_was_null(self):
waffle.get_waffle_flag_model().objects.create(name='foo', everyone=None)
with override_flag('foo', active=True):
assert waffle.flag_is_active(req(), 'foo')
with override_flag('foo', active=False):
assert not waffle.flag_is_active(req(), 'foo')
assert waffle.get_waffle_flag_model().objects.get(name='foo').everyone is None
def test_flag_did_not_exist(self):
assert not waffle.get_waffle_flag_model().objects.filter(name='foo').exists()
with override_flag('foo', active=True):
assert waffle.flag_is_active(req(), 'foo')
with override_flag('foo', active=False):
assert not waffle.flag_is_active(req(), 'foo')
assert not waffle.get_waffle_flag_model().objects.filter(name='foo').exists()
def test_flag_existed_and_was_null(self):
waffle.get_waffle_flag_model().objects.create(name='foo', everyone=None)
with override_flag('foo', active=True):
assert waffle.flag_is_active(req(), 'foo')
with override_flag('foo', active=False):
assert not waffle.flag_is_active(req(), 'foo')
assert waffle.get_waffle_flag_model().objects.get(name='foo').everyone is None
def test_persist_inactive_flag(self):
waffle.get_waffle_flag_model().objects.create(name='myflag', percent='99.9')
request = get()
# Flag stays off.
request.COOKIES['dwf_myflag'] = 'False'
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' in response.cookies
self.assertEqual('False', response.cookies['dwf_myflag'].value)
def test_percent(self, uniform):
"""If you have no cookie, you get a cookie!"""
uniform.return_value = '10'
waffle.get_waffle_flag_model().objects.create(name='myflag',
percent='50.0')
request = get()
response = process_request(request, views.flag_in_view)
assert 'dwf_myflag' in response.cookies
self.assertEqual('True', response.cookies['dwf_myflag'].value)
self.assertEqual(b'on', response.content)
def test_delete_some_but_not_all_records(self):
""" The command should delete specified records, but leave records
not specified alone. """
flag_1 = 'test_flag_1'
flag_2 = 'test_flag_2'
get_waffle_flag_model().objects.create(name=flag_1)
get_waffle_flag_model().objects.create(name=flag_2)
call_command('waffle_delete', flag_names=[flag_1])
self.assertTrue(get_waffle_flag_model().objects.filter(name=flag_2).exists())
def test_flag_did_not_exist(self):
assert not waffle.get_waffle_flag_model().objects.filter(name='foo').exists()
with override_flag('foo', active=True):
assert waffle.flag_is_active(req(), 'foo')
with override_flag('foo', active=False):
assert not waffle.flag_is_active(req(), 'foo')
assert not waffle.get_waffle_flag_model().objects.filter(name='foo').exists()
def test_flush_all_flags(self):
"""Test the 'FLAGS_ALL' list gets invalidated correctly."""
get_waffle_flag_model().objects.create(name='myflag1', everyone=True)
response = self.client.get(reverse('wafflejs'))
self.assertEqual(200, response.status_code)
assert ('myflag1', True) in response.context['flags']
get_waffle_flag_model().objects.create(name='myflag2', everyone=True)
response = self.client.get(reverse('wafflejs'))
self.assertEqual(200, response.status_code)
assert ('myflag2', True) in response.context['flags']
def test_delete_some_but_not_all_records(self):
""" The command should delete specified records, but leave records
not specified alone. """
flag_1 = 'test_flag_1'
flag_2 = 'test_flag_2'
get_waffle_flag_model().objects.create(name=flag_1)
get_waffle_flag_model().objects.create(name=flag_2)
call_command('waffle_delete', flag_names=[flag_1])
self.assertTrue(
get_waffle_flag_model().objects.filter(name=flag_2).exists())
def test_list(self):
""" The command should list all flags."""
stdout = six.StringIO()
get_waffle_flag_model().objects.create(name='test')
call_command('waffle_flag', list_flags=True, stdout=stdout)
expected = 'Flags:\nNAME: test\nSUPERUSERS: True\nEVERYONE: None\n' \
'AUTHENTICATED: False\nPERCENT: None\nTESTING: False\n' \
'ROLLOUT: False\nSTAFF: False\nGROUPS: []\nUSERS: []'
actual = stdout.getvalue().strip()
self.assertEqual(actual, expected)
def test_cache_is_flushed_by_testutils_even_in_transaction(self):
waffle.get_waffle_flag_model().objects.create(name='foo', everyone=True)
with transaction.atomic():
with override_flag('foo', active=True):
assert waffle.flag_is_active(req(), 'foo')
with override_flag('foo', active=False):
assert not waffle.flag_is_active(req(), 'foo')
assert waffle.flag_is_active(req(), 'foo')
def test_list(self):
""" The command should list all flags."""
stdout = six.StringIO()
get_waffle_flag_model().objects.create(name='test')
call_command('waffle_flag', list_flags=True, stdout=stdout)
expected = 'Flags:\nNAME: test\nSUPERUSERS: True\nEVERYONE: None\n' \
'AUTHENTICATED: False\nPERCENT: None\nTESTING: False\n' \
'ROLLOUT: False\nSTAFF: False\nGROUPS: []'
actual = stdout.getvalue().strip()
self.assertEqual(actual, expected)
def test_cache_is_flushed_by_testutils_even_in_transaction(self):
waffle.get_waffle_flag_model().objects.create(name='foo', everyone=True)
with transaction.atomic():
with override_flag('foo', active=True):
assert waffle.flag_is_active(req(), 'foo')
with override_flag('foo', active=False):
assert not waffle.flag_is_active(req(), 'foo')
assert waffle.flag_is_active(req(), 'foo')
def test_flush_all_flags(self):
"""Test the 'FLAGS_ALL' list gets invalidated correctly."""
get_waffle_flag_model().objects.create(name='myflag1', everyone=True)
response = self.client.get(reverse('wafflejs'))
self.assertEqual(200, response.status_code)
assert ('myflag1', True) in response.context['flags']
get_waffle_flag_model().objects.create(name='myflag2', everyone=True)
response = self.client.get(reverse('wafflejs'))
self.assertEqual(200, response.status_code)
assert ('myflag2', True) in response.context['flags']
def test_delete_mix_of_types(self):
""" The command should delete different types of records. """
name = 'test'
get_waffle_flag_model().objects.create(name=name)
Switch.objects.create(name=name)
Sample.objects.create(name=name, percent=0)
call_command('waffle_delete', switch_names=[name], flag_names=[name],
sample_names=[name])
self.assertEqual(get_waffle_flag_model().objects.count(), 0)
self.assertEqual(Switch.objects.count(), 0)
self.assertEqual(Sample.objects.count(), 0)
def test_natural_keys(self):
flag = get_waffle_flag_model().objects.create(name='test-flag')
switch = Switch.objects.create(name='test-switch')
sample = Sample.objects.create(name='test-sample', percent=0)
self.assertEqual(flag.natural_key(), ('test-flag',))
self.assertEqual(switch.natural_key(), ('test-switch',))
self.assertEqual(sample.natural_key(), ('test-sample',))
self.assertEqual(get_waffle_flag_model().objects.get_by_natural_key('test-flag'), flag)
self.assertEqual(Switch.objects.get_by_natural_key('test-switch'), switch)
self.assertEqual(Sample.objects.get_by_natural_key('test-sample'), sample)
def test_testing_flag(self):
waffle.get_waffle_flag_model().objects.create(name='foo', testing=True)
request = get(dwft_foo='1')
assert waffle.flag_is_active(request, 'foo')
assert 'foo' in request.waffle_tests
assert request.waffle_tests['foo']
# GET param should override cookie
request = get(dwft_foo='0')
request.COOKIES['dwft_foo'] = 'True'
assert not waffle.flag_is_active(request, 'foo')
assert 'foo' in request.waffle_tests
assert not request.waffle_tests['foo']
def test_testing_flag(self):
waffle.get_waffle_flag_model().objects.create(name='foo', testing=True)
request = get(dwft_foo='1')
assert waffle.flag_is_active(request, 'foo')
assert 'foo' in request.waffle_tests
assert request.waffle_tests['foo']
# GET param should override cookie
request = get(dwft_foo='0')
request.COOKIES['dwft_foo'] = 'True'
assert not waffle.flag_is_active(request, 'foo')
assert 'foo' in request.waffle_tests
assert not request.waffle_tests['foo']
def test_languages(self):
waffle.get_waffle_flag_model().objects.create(name='myflag', languages='en,fr')
request = get()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
request.LANGUAGE_CODE = 'en'
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
request.LANGUAGE_CODE = 'de'
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
def test_authenticated(self):
"""Test the authenticated/anonymous switch."""
waffle.get_waffle_flag_model().objects.create(name='myflag', authenticated=True)
request = get()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
request.user = get_user_model()(username='******')
assert request.user.is_authenticated
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
assert 'dwf_myflag' not in response.cookies
def test_delete_mix_of_types(self):
""" The command should delete different types of records. """
name = 'test'
get_waffle_flag_model().objects.create(name=name)
Switch.objects.create(name=name)
Sample.objects.create(name=name, percent=0)
call_command('waffle_delete',
switch_names=[name],
flag_names=[name],
sample_names=[name])
self.assertEqual(get_waffle_flag_model().objects.count(), 0)
self.assertEqual(Switch.objects.count(), 0)
self.assertEqual(Sample.objects.count(), 0)
def test_everyone_off(self):
"""Test the 'everyone' switch off."""
waffle.get_waffle_flag_model().objects.create(name='myflag', everyone=False, authenticated=True)
request = get()
request.COOKIES['dwf_myflag'] = 'True'
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
request.user = get_user_model()(username='******')
assert request.user.is_authenticated
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
def test_reroll(self, uniform):
"""Even without a cookie, calling flag_is_active twice should return
the same value."""
waffle.get_waffle_flag_model().objects.create(name='myflag', percent='50.0')
# Make sure we're not really random.
request = get() # Create a clean request.
assert not hasattr(request, 'waffles')
uniform.return_value = '10' # < 50. Flag is True.
assert waffle.flag_is_active(request, 'myflag')
assert hasattr(request, 'waffles') # We should record this flag.
assert 'myflag' in request.waffles
assert request.waffles['myflag'][0]
uniform.return_value = '70' # > 50. Normally, Flag would be False.
assert waffle.flag_is_active(request, 'myflag')
assert request.waffles['myflag'][0]
def test_testing_flag_header(self):
waffle.get_waffle_flag_model().objects.create(name='foo', testing=True)
request = RequestFactory().get('/foo', HTTP_DWFT_FOO='1')
request.user = AnonymousUser()
assert waffle.flag_is_active(request, 'foo')
assert 'foo' in request.waffle_tests
assert request.waffle_tests['foo']
# header should override cookie
request = RequestFactory().get('/foo', HTTP_DWFT_FOO='0')
request.user = AnonymousUser()
request.COOKIES['dwft_foo'] = 'True'
assert not waffle.flag_is_active(request, 'foo')
assert 'foo' in request.waffle_tests
assert not request.waffle_tests['foo']
def test_group(self):
"""Test the per-group switch."""
group = Group.objects.create(name='foo')
user = get_user_model().objects.create(username='******')
user.groups.add(group)
flag = waffle.get_waffle_flag_model().objects.create(name='myflag')
flag.groups.add(group)
request = get()
request.user = user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
assert 'dwf_myflag' not in response.cookies
request.user = get_user_model()(username='******')
request.user.save()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
# Unsetting the flag on a group should have an effect.
flag.groups.remove(group)
request.user = user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
def _generate_waffle_json(request):
flags = get_waffle_flag_model().get_all()
flag_values = {
f.name: {
'is_active': f.is_active(request),
'last_modified': f.modified,
}
for f in flags
}
switches = get_waffle_switch_model().get_all()
switch_values = {
s.name: {
'is_active': s.is_active(),
'last_modified': s.modified,
}
for s in switches
}
samples = get_waffle_sample_model().get_all()
sample_values = {
s.name: {
'is_active': s.is_active(),
'last_modified': s.modified,
}
for s in samples
}
return {
'flags': flag_values,
'switches': switch_values,
'samples': sample_values,
}
def test_set_then_unset_testing_flag(self):
waffle.get_waffle_flag_model().objects.create(name='myflag', testing=True)
response = self.client.get('/flag_in_view?dwft_myflag=1')
self.assertEqual(b'on', response.content)
response = self.client.get('/flag_in_view')
self.assertEqual(b'on', response.content)
response = self.client.get('/flag_in_view?dwft_myflag=0')
self.assertEqual(b'off', response.content)
response = self.client.get('/flag_in_view')
self.assertEqual(b'off', response.content)
response = self.client.get('/flag_in_view?dwft_myflag=1')
self.assertEqual(b'on', response.content)
def _set_up_default_feature_flags(cls):
""" """
Flag = get_waffle_flag_model()
default_mapping = copy.deepcopy(DEFAULT_FLAGS_CONFIG_MAPPING)
for config in default_mapping.values():
name = config.pop("name")
Flag.objects.get_or_create(name=name, defaults=config)
def test_user_append(self):
""" The command should append a user to a flag."""
original_user = User.objects.create_user('waffle_test')
User.objects.create_user('append_user')
User.objects.create_user('append_user_email', email='*****@*****.**')
flag = get_waffle_flag_model().objects.create(name='test')
flag.users.add(original_user)
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['waffle_test'])
call_command('waffle_flag', 'test', user=['append_user'],
append=True)
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['waffle_test', 'append_user'])
self.assertIsNone(flag.everyone)
call_command('waffle_flag', 'test', user=['*****@*****.**'],
append=True)
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['waffle_test', 'append_user', 'append_user_email'])
self.assertIsNone(flag.everyone)
def test_user_append(self):
""" The command should append a user to a flag."""
original_user = User.objects.create_user('waffle_test')
User.objects.create_user('append_user')
User.objects.create_user('append_user_email', email='*****@*****.**')
flag = get_waffle_flag_model().objects.create(name='test')
flag.users.add(original_user)
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['waffle_test'])
call_command('waffle_flag', 'test', user=['append_user'], append=True)
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['waffle_test', 'append_user'])
self.assertIsNone(flag.everyone)
call_command('waffle_flag',
'test',
user=['*****@*****.**'],
append=True)
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['waffle_test', 'append_user', 'append_user_email'])
self.assertIsNone(flag.everyone)
def test_group(self):
"""Test the per-group switch."""
group = Group.objects.create(name='foo')
user = get_user_model().objects.create(username='******')
user.groups.add(group)
flag = waffle.get_waffle_flag_model().objects.create(name='myflag')
flag.groups.add(group)
request = get()
request.user = user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
assert 'dwf_myflag' not in response.cookies
request.user = get_user_model()(username='******')
request.user.save()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
# Unsetting the flag on a group should have an effect.
flag.groups.remove(group)
request.user = user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
def test_remove_from_group(self):
"""Same operation of `test_group` but performed with reverse relation"""
group = Group.objects.create(name='foo')
user = get_user_model().objects.create(username='******')
user.groups.add(group)
flag = waffle.get_waffle_flag_model().objects.create(name='myflag')
flag.groups.add(group)
request = get()
request.user = user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
assert 'dwf_myflag' not in response.cookies
request.user = get_user_model()(username='******')
request.user.save()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
# Unsetting the flag on a group should have an effect.
group.flag_set.remove(flag)
request.user = user
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
def test_update_activate_everyone(self):
""" The command should update everyone field to True """
name = 'test'
flag = get_waffle_flag_model().objects.create(name=name)
self.assertIsNone(flag.percent)
self.assertIsNone(flag.everyone)
self.assertTrue(flag.superusers)
self.assertFalse(flag.staff)
self.assertFalse(flag.authenticated)
self.assertFalse(flag.rollout)
percent = 30
call_command('waffle_flag',
name,
everyone=True,
percent=percent,
superusers=False,
staff=True,
authenticated=True,
rollout=True)
flag.refresh_from_db()
self.assertEqual(flag.percent, percent)
self.assertTrue(flag.everyone)
self.assertFalse(flag.superusers)
self.assertTrue(flag.staff)
self.assertTrue(flag.authenticated)
self.assertTrue(flag.rollout)
def test_not_create(self):
""" The command shouldn't create a new flag if the create flag is
not set.
"""
name = 'test'
with self.assertRaisesRegexp(CommandError, 'This flag does not exist.'):
call_command('waffle_flag', name, everyone=True, percent=20,
superusers=True, staff=True, authenticated=True,
rollout=True)
self.assertFalse(get_waffle_flag_model().objects.filter(name=name).exists())
def test_superuser(self):
"""Test the superuser switch."""
waffle.get_waffle_flag_model().objects.create(name='myflag', superusers=True)
request = get()
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
superuser = get_user_model()(username='******', is_superuser=True)
request.user = superuser
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
assert 'dwf_myflag' not in response.cookies
non_superuser = get_user_model()(username='******', is_superuser=False)
non_superuser.save()
request.user = non_superuser
response = process_request(request, views.flag_in_view)
self.assertEqual(b'off', response.content)
assert 'dwf_myflag' not in response.cookies
def assert_flag_dynamically_created_with_value(self, expected_value):
FLAG_NAME = 'my_dynamically_created_flag'
flag_model = waffle.get_waffle_flag_model()
assert flag_model.objects.count() == 0
assert expected_value == waffle.flag_is_active(get(), FLAG_NAME)
assert flag_model.objects.count() == 1
flag = flag_model.objects.get(name=FLAG_NAME)
assert flag.name == FLAG_NAME
return flag
def test_everyone_on_read_from_write_db(self):
flag = waffle.get_waffle_flag_model().objects.create(name='myflag', everyone=True)
request = get()
response = process_request(request, views.flag_in_view)
# By default, flag_is_active should hit whatever it configured as the
# read DB (so values will be stale if replication is lagged).
self.assertEqual(b'off', response.content)
with override_settings(WAFFLE_READ_FROM_WRITE_DB=True):
# Save the flag again to flush the cache.
flag.save()
# The next read should now be directed to the write DB, ensuring
# the cache and DB are in sync.
response = process_request(request, views.flag_in_view)
self.assertEqual(b'on', response.content)
def test_user(self):
""" The command should replace a user to a flag."""
original_user = User.objects.create_user('waffle_test')
User.objects.create_user('add_user')
flag = get_waffle_flag_model().objects.create(name='test')
flag.users.add(original_user)
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['waffle_test'])
call_command('waffle_flag', 'test', user=['add_user'])
flag.refresh_from_db()
self.assertEqual(list(flag.users.values_list('username', flat=True)),
['add_user'])
self.assertIsNone(flag.everyone)
def test_create(self):
""" The command should create a new flag. """
name = 'test'
percent = 20
Group.objects.create(name='waffle_group')
call_command('waffle_flag', name, percent=percent,
superusers=True, staff=True, authenticated=True,
rollout=True, create=True, group=['waffle_group'])
flag = get_waffle_flag_model().objects.get(name=name)
self.assertEqual(flag.percent, percent)
self.assertIsNone(flag.everyone)
self.assertTrue(flag.superusers)
self.assertTrue(flag.staff)
self.assertTrue(flag.authenticated)
self.assertTrue(flag.rollout)
self.assertEqual(list(flag.groups.values_list('name', flat=True)),
['waffle_group'])
def _generate_waffle_js(request):
flags = get_waffle_flag_model().get_all()
flag_values = [(f.name, f.is_active(request)) for f in flags]
switches = Switch.get_all()
switch_values = [(s.name, s.is_active()) for s in switches]
samples = Sample.get_all()
sample_values = [(s.name, s.is_active()) for s in samples]
return loader.render_to_string('waffle/waffle.js', {
'flags': flag_values,
'switches': switch_values,
'samples': sample_values,
'flag_default': get_setting('FLAG_DEFAULT'),
'switch_default': get_setting('SWITCH_DEFAULT'),
'sample_default': get_setting('SAMPLE_DEFAULT'),
})
def test_group_append(self):
""" The command should append a group to a flag."""
original_group = Group.objects.create(name='waffle_group')
Group.objects.create(name='append_group')
flag = get_waffle_flag_model().objects.create(name='test')
flag.groups.add(original_group)
flag.refresh_from_db()
self.assertEqual(list(flag.groups.values_list('name', flat=True)),
['waffle_group'])
call_command('waffle_flag', 'test', group=['append_group'],
append=True)
flag.refresh_from_db()
self.assertEqual(list(flag.groups.values_list('name', flat=True)),
['waffle_group', 'append_group'])
self.assertIsNone(flag.everyone)
def handle(self, *args, **options):
flags = options['flag_names']
if flags:
flag_queryset = get_waffle_flag_model().objects.filter(name__in=flags)
flag_count = flag_queryset.count()
flag_queryset.delete()
self.stdout.write('Deleted %s Flags' % flag_count)
switches = options['switch_names']
if switches:
switches_queryset = Switch.objects.filter(name__in=switches)
switch_count = switches_queryset.count()
switches_queryset.delete()
self.stdout.write('Deleted %s Switches' % switch_count)
samples = options['sample_names']
if samples:
sample_queryset = Sample.objects.filter(name__in=samples)
sample_count = sample_queryset.count()
sample_queryset.delete()
self.stdout.write('Deleted %s Samples' % sample_count)
