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']))
