def test_valid_traffic_fractions_save(self): # test the hidden prop gets set exp = Experiment.find_or_create('dist-02', ['dist', '100'], traffic_fraction=0.02, redis=self.redis) self.assertEqual(exp._traffic_fraction, 0.02) exp = Experiment.find_or_create('dist-100', ['dist', '100'], traffic_fraction=0.4, redis=self.redis) self.assertEqual(exp._traffic_fraction, 0.40)
def test_differing_alternatives_fails(self): exp = Experiment.find_or_create("load-differing-alts", ["yes", "zack", "PBR"], self.redis) alts = Experiment.load_alternatives(exp.name, self.redis) self.assertEqual(sorted(alts), sorted(["PBR", "yes", "zack"])) with self.assertRaises(ValueError): exp = Experiment.find_or_create("load-differing-alts", ["kyle", "zack", "PBR"], self.redis)
def test_dont_fail_when_participating_in_nondefault_traffic_experiment_without_traffic_param( self): Experiment.find_or_create('red-white', ['red', 'white'], traffic_fraction=0.5, redis=self.redis) Experiment.find_or_create('red-white', ['red', 'white'], redis=self.redis)
def test_valid_traffic_fractions_save(self): # test the hidden prop gets set exp = Experiment.find_or_create('dist-02', ['dist', '100'], traffic_fraction=0.02, redis=self.redis) self.assertEqual(exp._traffic_fraction, 0.02) exp = Experiment.find_or_create('dist-100', ['dist', '100'], traffic_fraction=0.4, redis=self.redis) self.assertEqual(exp._traffic_fraction, 0.40)
def test_differing_alternatives_fails(self): exp = Experiment.find_or_create('load-differing-alts', ['yes', 'zack', 'PBR'], redis=self.redis) alts = Experiment.load_alternatives(exp.name, redis=self.redis) self.assertEqual(sorted(alts), sorted(['PBR', 'yes', 'zack'])) with self.assertRaises(ValueError): exp = Experiment.find_or_create('load-differing-alts', ['kyle', 'zack', 'PBR'], redis=self.redis)
def test_differing_alternatives_fails(self): exp = Experiment.find_or_create('load-differing-alts', ['yes', 'zack', 'PBR'], redis=self.redis) alts = Experiment.load_alternatives(exp.name, redis=self.redis) self.assertEqual(sorted(alts), sorted(['PBR', 'yes', 'zack'])) with self.assertRaises(ValueError): exp = Experiment.find_or_create('load-differing-alts', ['kyle', 'zack', 'PBR'], redis=self.redis)
def test_valid_options(self): Experiment.find_or_create('red-white', ['red', 'white'], traffic_fraction=1, redis=self.redis) Experiment.find_or_create('red-white-2', ['red', 'white'], traffic_fraction=0.4, redis=self.redis)
def test_valid_options(self): opts = {'distribution': 1} Experiment.find_or_create('red-white', ['red', 'white'], self.redis, opts) opts = {'distribution': '1'} Experiment.find_or_create('red-white', ['red', 'white'], self.redis, opts)
def test_change_alternatives(self): exp = Experiment.find_or_create("never-gonna-x", ["let", "you", "down"], self.redis) with self.assertRaises(ValueError): Experiment.find_or_create("never-gonna-x", ["let", "you", "down", "give", "you", "up"], self.redis) exp.delete() Experiment.find_or_create("never-gonna-x", ["let", "you", "down", "give", "you", "up"], self.redis)
def test_fail_when_changing_traffic(self): Experiment.find_or_create('red-white', ['red', 'white'], traffic_fraction=0.8, redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('red-white', ['red', 'white'], traffic_fraction=0.4, redis=self.redis)
def test_changing_traffic_fraction_succeeds(self): exp = Experiment.find_or_create('red-white', ['red', 'white'], traffic_fraction=1, redis=self.redis) self.assertEqual(exp._traffic_fraction, 1) exp = Experiment.find_or_create('red-white', ['red', 'white'], traffic_fraction=0.4, redis=self.redis) self.assertEqual(exp._traffic_fraction, 0.4)
def test_change_alternatives(self): exp = Experiment.find_or_create('never-gonna-x', ['let', 'you', 'down'], redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('never-gonna-x', ['let', 'you', 'down', 'give', 'you', 'up'], redis=self.redis) exp.delete() Experiment.find_or_create('never-gonna-x', ['let', 'you', 'down', 'give', 'you', 'up'], redis=self.redis)
def test_change_alternatives(self): exp = Experiment.find_or_create('never-gonna-x', ['let', 'you', 'down'], redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('never-gonna-x', ['let', 'you', 'down', 'give', 'you', 'up'], redis=self.redis) exp.delete() Experiment.find_or_create('never-gonna-x', ['let', 'you', 'down', 'give', 'you', 'up'], redis=self.redis)
def test_valid_traffic_fractions_save(self): # test the hidden prop gets set opts = {'traffic_fraction': 0.02} exp = Experiment.find_or_create('dist-02', ['dist', '100'], self.redis, opts) self.assertEqual(exp._traffic_fraction, 0.02) opts = {'traffic_fraction': 0.4} exp = Experiment.find_or_create('dist-100', ['dist', '100'], self.redis, opts) self.assertEqual(exp._traffic_fraction, 0.40)
def test_find_or_create(self): # should throw a ValueError if alters are invalid with self.assertRaises(ValueError): Experiment.find_or_create('party-time', ['1'], redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('party-time', ['1', '*****'], redis=self.redis) # should create a -NEW- experiment if experiment has never been used with self.assertRaises(ValueError): Experiment.find('dance-dance', redis=self.redis)
def test_find_or_create(self): # should throw a ValueError if alters are invalid with self.assertRaises(ValueError): Experiment.find_or_create('party-time', ['1'], redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('party-time', ['1', '*****'], redis=self.redis) # should create a -NEW- experiment if experiment has never been used with self.assertRaises(ValueError): Experiment.find('dance-dance', redis=self.redis)
def test_find_or_create(self): # should throw a ValueError if alters are invalid with self.assertRaises(ValueError): Experiment.find_or_create("party-time", ["1"], self.redis) with self.assertRaises(ValueError): Experiment.find_or_create("party-time", ["1", "*****"], self.redis) # should create a -NEW- experiment if experiment has never been used with self.assertRaises(ValueError): Experiment.find("dance-dance", self.redis)
def test_invalid_dist(self): opts = {'distribution': 0} with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], self.redis, opts) opts = {'distribution': 101} with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], self.redis, opts) opts = {'distribution': 'x'} with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], self.redis, opts) # test the hidden prop gets set opts = {'distribution': 2} exp = Experiment.find_or_create('dist-20', ['dist', '100'], self.redis, opts) self.assertEqual(exp._traffic_dist, .02) opts = {'distribution': 100} exp = Experiment.find_or_create('dist-100', ['dist', '100'], self.redis, opts) self.assertEqual(exp._traffic_dist, 1.00)
def test_excluded_client(self): # need proper redis to register the msetbit script import sixpack.db sixpack.db.REDIS.flushall() e = Experiment.find_or_create('excluded-client', ['option-a', 'option-b'], redis=sixpack.db.REDIS) self.assertEqual(e.control.participant_count(), 0) self.assertEqual(e.control.completed_count(), 0) # force participate 1 proper client on the control alternative cnil = Client("cnil", redis=sixpack.db.REDIS) e.control.record_participation(cnil) e.convert(cnil) # exclude client, gets control alternative & try to convert c = Client("c", redis=sixpack.db.REDIS) e.exclude_client(c) self.assertTrue(e.control == e.get_alternative(c)) self.assertTrue(None == e.existing_alternative(c)) with self.assertRaises(ValueError): e.convert(c) # participation & completed count should be 1 self.assertEqual(e.control.participant_count(), 1) self.assertEqual(e.control.completed_count(), 1)
def test_description(self): exp = Experiment.find_or_create('never-gonna', ['give', 'you', 'up'], redis=self.redis) self.assertEqual(exp.description, None) exp.update_description('hallo') self.assertEqual(exp.description, 'hallo')
def test_set_kpi(self): exp = Experiment.find_or_create('multi-kpi', ['kpi', '123'], redis=self.redis) # We shouldn't beable to manually set a KPI. Only via web request with self.assertRaises(ValueError): exp.set_kpi('bananza') # simulate conversion via webrequest client = Client(100, redis=self.redis) exp.get_alternative(client) exp.convert(client, None, 'bananza') exp2 = Experiment.find_or_create('multi-kpi', ['kpi', '123'], redis=self.redis) self.assertEqual(exp2.kpi, None) exp2.set_kpi('bananza') self.assertEqual(exp2.kpi, 'bananza')
def test_get_alternative(self): client = Client(10, redis=self.redis) exp = Experiment.find_or_create('pause-control', ['w', 'l'], redis=self.redis) exp.pause() # should return control on paused test with no winner alt = exp.get_alternative(client) self.assertEqual(alt.name, 'w') # should return current participation exp.resume() # should be one or the other. # @todo, this test is not really testing anything. selected_for_client = exp.get_alternative(client) self.assertIn(selected_for_client.name, ['w', 'l']) # should check to see if client is participating and only return the same alt # unsure how to currently test since fakeredis obviously doesn't parse lua # most likely integration tests exp.archive() # test if the redis key is no longer present self.redis.get(_key('e:{0}:users'.format(exp.name))) # should return control on archived test alt = exp.get_alternative(client) self.assertEqual(alt.name, 'w')
def test_excluded_client(self): # need proper redis to register the msetbit script import sixpack.db sixpack.db.REDIS.flushall() e = Experiment.find_or_create('excluded-client', ['option-a', 'option-b'], redis=sixpack.db.REDIS) self.assertEqual(e.control.participant_count(), 0) self.assertEqual(e.control.completed_count(), 0) # force participate 1 proper client on the control alternative cnil = Client("cnil", redis=sixpack.db.REDIS) e.control.record_participation(cnil) e.convert(cnil) # exclude client, gets control alternative & try to convert c = Client("c", redis=sixpack.db.REDIS) e.exclude_client(c) self.assertTrue(e.control == e.get_alternative(c)) self.assertTrue(None == e.existing_alternative(c)) with self.assertRaises(ValueError): e.convert(c) # participation & completed count should be 1 self.assertEqual(e.control.participant_count(), 1) self.assertEqual(e.control.completed_count(), 1)
def test_set_kpi(self): exp = Experiment.find_or_create('multi-kpi', ['kpi', '123'], redis=self.redis) # We shouldn't beable to manually set a KPI. Only via web request with self.assertRaises(ValueError): exp.set_kpi('bananza') # simulate conversion via webrequest client = Client(100, redis=self.redis) exp.get_alternative(client) exp.convert(client, None, 'bananza') exp2 = Experiment.find_or_create('multi-kpi', ['kpi', '123'], redis=self.redis) self.assertEqual(exp2.kpi, None) exp2.set_kpi('bananza') self.assertEqual(exp2.kpi, 'bananza')
def test_get_alternative(self): client = Client(10, redis=self.redis) exp = Experiment.find_or_create('pause-control', ['w', 'l'], redis=self.redis) exp.pause() # should return control on paused test with no winner alt = exp.get_alternative(client) self.assertEqual(alt.name, 'w') # should return current participation exp.resume() # should be one or the other. # @todo, this test is not really testing anything. selected_for_client = exp.get_alternative(client) self.assertIn(selected_for_client.name, ['w', 'l']) # should check to see if client is participating and only return the same alt # unsure how to currently test since fakeredis obviously doesn't parse lua # most likely integration tests exp.archive() # test if the redis key is no longer present self.redis.get(_key('e:{0}:users'.format(exp.name))) # should return control on archived test alt = exp.get_alternative(client) self.assertEqual(alt.name, 'w')
def test_winner(self): exp = Experiment.find_or_create('test-get-winner', ['1', '2'], redis=self.redis) self.assertIsNone(exp.winner) exp.set_winner('1') self.assertEqual(exp.winner.name, '1')
def test_add_kpi(self): exp = Experiment.find_or_create('multi-kpi-add', ['asdf', '999'], redis=self.redis) kpi = 'omg-pop' exp.add_kpi(kpi) key = "{0}:kpis".format(exp.key(include_kpi=False)) self.assertIn(kpi, self.redis.smembers(key)) exp.delete()
def test_winner_saves_to_db(self): e = Experiment.find_or_create('winner-saves-to-db', ['one', 'two'], redis=self.app.redis) client = SClient('random', redis=self.app.redis) e.set_winner('two') self.assertEqual('two', e.get_alternative(client).name) e.set_winner('one') self.assertEqual('two', e.get_alternative(client).name)
def test_add_kpi(self): exp = Experiment.find_or_create('multi-kpi-add', ['asdf', '999'], redis=self.redis) kpi = 'omg-pop' exp.add_kpi(kpi) key = "{0}:kpis".format(exp.key(include_kpi=False)) self.assertIn(kpi, self.redis.smembers(key)) exp.delete()
def test_add_kpi(self): exp = Experiment.find_or_create("multi-kpi-add", ["asdf", "999"], self.redis) kpi = "omg-pop" exp.add_kpi(kpi) key = "{0}:kpis".format(exp.key(include_kpi=False)) self.assertIn(kpi, self.redis.smembers(key)) exp.delete()
def test_set_kpi(self): exp = Experiment.find_or_create("multi-kpi", ["kpi", "123"], self.redis) # We shouldn't beable to manually set a KPI. Only via web request with self.assertRaises(ValueError): exp.set_kpi("bananza") # simulate conversion via webrequest client = Client(100, self.redis) # hack for disabling whiplash exp.random_sample = 1 exp.get_alternative(client) exp.convert(client, None, "bananza") exp2 = Experiment.find_or_create("multi-kpi", ["kpi", "123"], self.redis) self.assertEqual(exp2.kpi, None) exp2.set_kpi("bananza") self.assertEqual(exp2.kpi, "bananza")
def test_excluded_clients(self): e = Experiment.find_or_create('count-excluded-clients', ['red', 'blue'], redis=self.redis) for i in range(10): c = Client("c-%d" % i, self.redis) e.exclude_client(c) # there is a very small chance that a client was not excluded. self.assertEqual(e.excluded_clients(), i + 1)
def test_kpis(self): exp = Experiment.find_or_create('multi-kpi-add', ['asdf', '999'], redis=self.redis) kpis = ['omg-pop', 'zynga'] exp.add_kpi(kpis[0]) exp.add_kpi(kpis[1]) ekpi = exp.kpis self.assertIn(kpis[0], ekpi) self.assertIn(kpis[1], ekpi) exp.delete()
def test_get_kpis(self): exp = Experiment.find_or_create("multi-kpi-add", ["asdf", "999"], self.redis) kpis = ["omg-pop", "zynga"] exp.add_kpi(kpis[0]) exp.add_kpi(kpis[1]) ekpi = exp.get_kpis() self.assertIn(kpis[0], ekpi) self.assertIn(kpis[1], ekpi) exp.delete()
def test_kpis(self): exp = Experiment.find_or_create('multi-kpi-add', ['asdf', '999'], redis=self.redis) kpis = ['omg-pop', 'zynga'] exp.add_kpi(kpis[0]) exp.add_kpi(kpis[1]) ekpi = exp.kpis self.assertIn(kpis[0], ekpi) self.assertIn(kpis[1], ekpi) exp.delete()
def test_bots_get_winner_otherwise_control(self): e = Experiment.find_or_create("bots-get-winner", ["one", "two"], redis=self.app.redis) # control at first for i in range(3): data = json.loads(self.client.get("/participate?experiment=bots-get-winner&alternatives=one&alternatives=two&user_agent=GoogleBot&client_id=rand").data) self.assertEqual(data['alternative']['name'], 'one') # winner once one is set e.set_winner("two") for i in range(3): data = json.loads(self.client.get("/participate?experiment=bots-get-winner&alternatives=one&alternatives=two&user_agent=GoogleBot&client_id=rand").data) self.assertEqual(data['alternative']['name'], 'two')
def test_reset_experiment(self): client = Client(10, redis=self.redis) exp = Experiment.find_or_create('reset-test', ['w', 'l'], redis=self.redis) exp.get_alternative(client) # archive and afterwards reset to see if we # actually reset the data. exp.archive() self.assertEqual(exp.is_archived(), True) exp.reset() self.assertEqual(exp.is_archived(), False)
def test_excluded_clients(self): e = Experiment.find_or_create('count-excluded-clients', ['red', 'blue'], redis=self.redis) for i in range(10): c = Client("c-%d" % i, self.redis) e.exclude_client(c) # there is a very small chance that a client was not excluded. self.assertEqual(e.excluded_clients(), i + 1)
def test_client_chosen_alternative(self): alts = ["one", "two", "three"] e = Experiment.find_or_create("client-chosen-alternative", alts, redis=self.app.redis) data = json.loads(self.client.get("/participate?experiment=client-chosen-alternative&alternatives=one&alternatives=two&alternatives=three&client_id=1&alternative=one").data) self.assertEqual(data['alternative']['name'], 'one') self.assertEqual(e.total_participants(), 1) data = json.loads(self.client.get("/participate?experiment=client-chosen-alternative&alternatives=one&alternatives=two&alternatives=three&client_id=2&alternative=two").data) self.assertEqual(data['alternative']['name'], 'two') self.assertEqual(e.total_participants(), 2)
def test_reset_experiment(self): client = Client(10, redis=self.redis) exp = Experiment.find_or_create('reset-test', ['w', 'l'], redis=self.redis) exp.get_alternative(client) # archive and afterwards reset to see if we # actually reset the data. exp.archive() self.assertEqual(exp.is_archived(), True) exp.reset() self.assertEqual(exp.is_archived(), False)
def test_force_param_always_wins(self): alts = ["one", "two", "three"] e = Experiment.find_or_create("force-param-always-wins", alts, redis=self.app.redis) def test_force(): for f in alts: data = json.loads(self.client.get("/participate?experiment=force-param-always-wins&alternatives=one&alternatives=two&alternatives=three&client_id=rand&force={0}".format(f)).data) self.assertEqual(data['alternative']['name'], f) # before a winner test_force() e.set_winner("three") # after a winner test_force()
def test_valid_options(self): opts = {'traffic_fraction': 1} Experiment.find_or_create('red-white', ['red', 'white'], self.redis, opts) opts = {'traffic_fraction': 0} Experiment.find_or_create('red-white', ['red', 'white'], self.redis, opts) opts = {'traffic_fraction': 0.4} Experiment.find_or_create('red-white', ['red', 'white'], self.redis, opts)
def test_invalid_traffic_fraction(self): with self.assertRaises(ValueError): Experiment.find_or_create('dist-2', ['dist', '2'], traffic_fraction=2, redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], traffic_fraction=101, redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], traffic_fraction="x", redis=self.redis)
def test_invalid_traffic_fraction(self): with self.assertRaises(ValueError): Experiment.find_or_create('dist-2', ['dist', '2'], traffic_fraction=2, redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], traffic_fraction=101, redis=self.redis) with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], traffic_fraction="x", redis=self.redis)
def test_get_alternative(self): client = Client(10, redis=self.redis) exp = Experiment.find_or_create('archived-control', ['w', 'l'], redis=self.redis) exp.archive() # should return control on archived test with no winner alt = exp.get_alternative(client) self.assertEqual(alt.name, 'w') # should return current participation exp.unarchive() selected_for_client = exp.get_alternative(client) self.assertIn(selected_for_client.name, ['w', 'l'])
def test_get_alternative(self): client = Client(10, redis=self.redis) exp = Experiment.find_or_create('archived-control', ['w', 'l'], redis=self.redis) exp.archive() # should return control on archived test with no winner alt = exp.get_alternative(client) self.assertEqual(alt.name, 'w') # should return current participation exp.unarchive() selected_for_client = exp.get_alternative(client) self.assertIn(selected_for_client.name, ['w', 'l'])
def test_invalid_traffic_fraction(self): opts = {'traffic_fraction': 2} with self.assertRaises(ValueError): Experiment.find_or_create('dist-2', ['dist', '2'], self.redis, opts) opts = {'traffic_fraction': 101} with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], self.redis, opts) opts = {'traffic_fraction': 'x'} with self.assertRaises(ValueError): Experiment.find_or_create('dist-100', ['dist', '100'], self.redis, opts)
def test_get_alternative(self): client = Client(10, self.redis) exp = Experiment.find_or_create("archived-control", ["w", "l"], self.redis) exp.archive() # should return control on archived test with no winner alt = exp.get_alternative(client) self.assertEqual(alt.name, "w") # should return current participation exp.unarchive() ### HACK TO SKIP WHIPLASH TESTS exp.random_sample = 1 ### HACK TO SKIP WHIPLASH TESTS selected_for_client = exp.get_alternative(client) self.assertIn(selected_for_client.name, ["w", "l"])
def test_invalid_dist(self): opts = {"distribution": 0} with self.assertRaises(ValueError): Experiment.find_or_create("dist-100", ["dist", "100"], self.redis, opts) opts = {"distribution": 101} with self.assertRaises(ValueError): Experiment.find_or_create("dist-100", ["dist", "100"], self.redis, opts) opts = {"distribution": "x"} with self.assertRaises(ValueError): Experiment.find_or_create("dist-100", ["dist", "100"], self.redis, opts) # test the hidden prop gets set opts = {"distribution": 2} exp = Experiment.find_or_create("dist-20", ["dist", "100"], self.redis, opts) self.assertEqual(exp._traffic_dist, 0.02) opts = {"distribution": 100} exp = Experiment.find_or_create("dist-100", ["dist", "100"], self.redis, opts) self.assertEqual(exp._traffic_dist, 1.00)
def test_get_alternative(self): client = Client(10, self.redis) exp = Experiment.find_or_create('archived-control', ['w', 'l'], self.redis) exp.archive() # should return control on archived test with no winner alt = exp.get_alternative(client) self.assertEqual(alt.name, 'w') # should return current participation exp.unarchive() ### HACK TO SKIP WHIPLASH TESTS exp.random_sample = 1 ### HACK TO SKIP WHIPLASH TESTS selected_for_client = exp.get_alternative(client) self.assertIn(selected_for_client.name, ['w', 'l'])
def test_client_chosen_alternative(self): alts = ["one", "two", "three"] e = Experiment.find_or_create("client-chosen-alternative", alts, redis=self.app.redis) data = json.loads( self.client.get( "/participate?experiment=client-chosen-alternative&alternatives=one&alternatives=two&alternatives=three&client_id=1&alternative=one" ).data) self.assertEqual(data['alternative']['name'], 'one') self.assertEqual(e.total_participants(), 1) data = json.loads( self.client.get( "/participate?experiment=client-chosen-alternative&alternatives=one&alternatives=two&alternatives=three&client_id=2&alternative=two" ).data) self.assertEqual(data['alternative']['name'], 'two') self.assertEqual(e.total_participants(), 2)
def test_traffic_fraction(self): exp = Experiment.find_or_create('d-test-10', ['d', 'c'], traffic_fraction=0.1, redis=self.redis) exp.save() self.assertEqual(exp.traffic_fraction, 0.1)
def test_traffic_dist(self): opts = {'distribution': 10} exp = Experiment.find_or_create('d-test-10', ['d', 'c'], self.redis, opts) exp.save() self.assertEqual(exp.traffic_dist, 0.1)
def test_description(self): exp = Experiment.find_or_create('never-gonna', ['give', 'you', 'up'], redis=self.redis) self.assertEqual(exp.description, None) exp.update_description('hallo') self.assertEqual(exp.description, 'hallo')
def test_invalid_options(self): opts = {'derp': 'ington'} with self.assertRaises(ValueError): Experiment.find_or_create('jay-fi', ['jay', 'fi'], self.redis, opts)
def test_traffic_fraction(self): exp = Experiment.find_or_create('d-test-10', ['d', 'c'], traffic_fraction=0.1, redis=self.redis) exp.save() self.assertEqual(exp.traffic_fraction, 0.1)
def test_winner_key(self): exp = Experiment.find_or_create('winner-key', ['win', 'lose'], redis=self.redis) self.assertEqual(exp._winner_key, "{0}:winner".format(exp.key()))
def test_load_alternatives(self): exp = Experiment.find_or_create('load-alts-test', ['yes', 'no', 'call-me-maybe'], redis=self.redis) alts = Experiment.load_alternatives(exp.name, redis=self.redis) self.assertEqual(sorted(alts), sorted(['yes', 'no', 'call-me-maybe']))