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_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_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_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_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_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_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_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_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)