def test_variation_when_user_has_no_key():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
expected = EvaluationDetail('default', None, {'kind': 'ERROR', 'errorKind': 'USER_NOT_SPECIFIED'})
assert expected == client.variation_detail('feature.key', { }, default='default')
def test_all_flags_state_returns_state_with_reasons():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
state = client.all_flags_state(user, with_reasons=True)
assert state.valid == True
result = state.to_json_dict()
assert result == {
'key1': 'value1',
'key2': 'value2',
'$flagsState': {
'key1': {
'variation': 0,
'version': 100,
'reason': {'kind': 'OFF'}
},
'key2': {
'variation': 1,
'version': 200,
'trackEvents': True,
'debugEventsUntilDate': 1000,
'reason': {'kind': 'OFF'}
}
},
'$valid': True
}
def test_all_flags_state_returns_state_with_reasons():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
state = client.all_flags_state(user, with_reasons=True)
assert state.valid == True
result = state.to_json_dict()
assert result == {
'key1': 'value1',
'key2': 'value2',
'$flagsState': {
'key1': {
'variation': 0,
'version': 100,
'reason': {'kind': 'OFF'}
},
'key2': {
'variation': 1,
'version': 200,
'trackEvents': True,
'debugEventsUntilDate': 1000,
'reason': {'kind': 'OFF'}
}
},
'$valid': True
}
def test_variation_detail_for_existing_feature():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
expected = EvaluationDetail('value', 0, {'kind': 'OFF'})
assert expected == client.variation_detail('feature.key', user, default='default')
def test_variation_detail_when_user_has_no_key():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
expected = EvaluationDetail('default', None, {'kind': 'ERROR', 'errorKind': 'USER_NOT_SPECIFIED'})
assert expected == client.variation_detail('feature.key', { }, default='default')
def test_event_for_existing_feature_with_tracked_rule():
feature = {
'key': 'feature.key',
'version': 100,
'salt': u'',
'on': True,
'rules': [
{
'clauses': [
{ 'attribute': 'key', 'op': 'in', 'values': [ user['key'] ] }
],
'variation': 0,
'trackEvents': True,
'id': 'rule_id'
}
],
'variations': [ 'value' ]
}
store = InMemoryFeatureStore()
store.init({FEATURES: {feature['key']: feature}})
client = make_client(store)
assert 'value' == client.variation(feature['key'], user, default='default')
e = get_first_event(client)
assert (e['kind'] == 'feature' and
e['key'] == feature['key'] and
e['user'] == user and
e['version'] == feature['version'] and
e['value'] == 'value' and
e['variation'] == 0 and
e['reason'] == { 'kind': 'RULE_MATCH', 'ruleIndex': 0, 'ruleId': 'rule_id' } and
e['default'] == 'default' and
e['trackEvents'] == True and
e.get('debugEventsUntilDate') is None)
def test_event_for_existing_feature_with_untracked_fallthrough():
feature = {
'key': 'feature.key',
'version': 100,
'salt': u'',
'on': True,
'rules': [],
'fallthrough': { 'variation': 0 },
'variations': [ 'value' ],
'trackEventsFallthrough': False
}
store = InMemoryFeatureStore()
store.init({FEATURES: {feature['key']: feature}})
client = make_client(store)
assert 'value' == client.variation(feature['key'], user, default='default')
e = get_first_event(client)
assert (e['kind'] == 'feature' and
e['key'] == feature['key'] and
e['user'] == user and
e['version'] == feature['version'] and
e['value'] == 'value' and
e['variation'] == 0 and
e.get('reason') is None and
e['default'] == 'default' and
e.get('trackEvents', False) == False and
e.get('debugEventsUntilDate') is None)
def test_variation_detail_for_existing_feature():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
expected = EvaluationDetail('value', 0, {'kind': 'OFF'})
assert expected == client.variation_detail('feature.key', user, default='default')
def test_variation_when_user_is_none():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
assert 'default' == client.variation('feature.key',
None,
default='default')
def test_variation_for_flag_that_evaluates_to_none():
empty_flag = {'key': 'feature.key', 'on': False, 'offVariation': None}
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': empty_flag}})
client = make_client(store)
assert 'default' == client.variation('feature.key',
user,
default='default')
def test_variation_detail_for_flag_that_evaluates_to_none():
empty_flag = {'key': 'feature.key', 'on': False, 'offVariation': None}
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': empty_flag}})
client = make_client(store)
expected = EvaluationDetail('default', None, {'kind': 'OFF'})
actual = client.variation_detail('feature.key', user, default='default')
assert expected == actual
assert actual.is_default_value() == True
def test_variation_for_flag_that_evaluates_to_none():
empty_flag = {
'key': 'feature.key',
'on': False,
'offVariation': None
}
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': empty_flag}})
client = make_client(store)
assert 'default' == client.variation('feature.key', user, default='default')
def test_all_flags_state_can_omit_details_for_untracked_flags():
future_time = (time.time() * 1000) + 100000
flag1 = {
'key': 'key1',
'version': 100,
'on': False,
'offVariation': 0,
'variations': [ 'value1' ],
'trackEvents': False
}
flag2 = {
'key': 'key2',
'version': 200,
'on': False,
'offVariation': 1,
'variations': [ 'x', 'value2' ],
'trackEvents': True
}
flag3 = {
'key': 'key3',
'version': 300,
'on': False,
'offVariation': 1,
'variations': [ 'x', 'value3' ],
'debugEventsUntilDate': future_time
}
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2, 'key3': flag3 } })
client = make_client(store)
state = client.all_flags_state(user, with_reasons=True, details_only_for_tracked_flags=True)
assert state.valid == True
result = state.to_json_dict()
assert result == {
'key1': 'value1',
'key2': 'value2',
'key3': 'value3',
'$flagsState': {
'key1': {
'variation': 0
},
'key2': {
'variation': 1,
'version': 200,
'trackEvents': True,
'reason': {'kind': 'OFF'}
},
'key3': {
'variation': 1,
'version': 300,
'debugEventsUntilDate': future_time,
'reason': {'kind': 'OFF'}
}
},
'$valid': True
}
def test_all_flags_state_can_omit_details_for_untracked_flags():
future_time = (time.time() * 1000) + 100000
flag1 = {
'key': 'key1',
'version': 100,
'on': False,
'offVariation': 0,
'variations': [ 'value1' ],
'trackEvents': False
}
flag2 = {
'key': 'key2',
'version': 200,
'on': False,
'offVariation': 1,
'variations': [ 'x', 'value2' ],
'trackEvents': True
}
flag3 = {
'key': 'key3',
'version': 300,
'on': False,
'offVariation': 1,
'variations': [ 'x', 'value3' ],
'debugEventsUntilDate': future_time
}
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2, 'key3': flag3 } })
client = make_client(store)
state = client.all_flags_state(user, with_reasons=True, details_only_for_tracked_flags=True)
assert state.valid == True
result = state.to_json_dict()
assert result == {
'key1': 'value1',
'key2': 'value2',
'key3': 'value3',
'$flagsState': {
'key1': {
'variation': 0
},
'key2': {
'variation': 1,
'version': 200,
'trackEvents': True,
'reason': {'kind': 'OFF'}
},
'key3': {
'variation': 1,
'version': 300,
'debugEventsUntilDate': future_time,
'reason': {'kind': 'OFF'}
}
},
'$valid': True
}
def test_event_for_unknown_feature():
store = InMemoryFeatureStore()
store.init({FEATURES: {}})
client = make_client(store)
assert 'default' == client.variation('feature.key',
user,
default='default')
e = get_first_event(client)
assert (e['kind'] == 'feature' and e['key'] == 'feature.key'
and e['user'] == user and e['value'] == 'default'
and e['variation'] == None and e['default'] == 'default')
def test_event_for_unknown_feature():
store = InMemoryFeatureStore()
store.init({FEATURES: {}})
with make_client(store) as client:
assert 'default' == client.variation('feature.key', user, default='default')
e = get_first_event(client)
assert (e['kind'] == 'feature' and
e['key'] == 'feature.key' and
e['user'] == user and
e['value'] == 'default' and
e['variation'] == None and
e['default'] == 'default')
def test_variation_detail_for_flag_that_evaluates_to_none():
empty_flag = {
'key': 'feature.key',
'on': False,
'offVariation': None
}
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': empty_flag}})
client = make_client(store)
expected = EvaluationDetail('default', None, {'kind': 'OFF'})
actual = client.variation_detail('feature.key', user, default='default')
assert expected == actual
assert actual.is_default_value() == True
def test_event_for_existing_feature():
feature = make_off_flag_with_value('feature.key', 'value')
feature['trackEvents'] = True
feature['debugEventsUntilDate'] = 1000
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
assert 'value' == client.variation('feature.key', user, default='default')
e = get_first_event(client)
assert (e['kind'] == 'feature' and e['key'] == 'feature.key'
and e['user'] == user and e['version'] == feature['version']
and e['value'] == 'value' and e['variation'] == 0
and e.get('reason') is None and e['default'] == 'default'
and e['trackEvents'] == True and e['debugEventsUntilDate'] == 1000)
def test_event_for_existing_feature_with_no_user_key():
feature = make_off_flag_with_value('feature.key', 'value')
feature['trackEvents'] = True
feature['debugEventsUntilDate'] = 1000
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
bad_user = {u'name': u'Bob'}
assert 'default' == client.variation('feature.key',
bad_user,
default='default')
e = get_first_event(client)
assert (e['kind'] == 'feature' and e['key'] == 'feature.key'
and e['user'] == bad_user and e['version'] == feature['version']
and e['value'] == 'default' and e['variation'] == None
and e['default'] == 'default' and e['trackEvents'] == True
and e['debugEventsUntilDate'] == 1000)
def test_all_flags_state_can_be_filtered_for_client_side_flags():
flag1 = {
'key': 'server-side-1',
'on': False,
'offVariation': 0,
'variations': ['a'],
'clientSide': False
}
flag2 = {
'key': 'server-side-2',
'on': False,
'offVariation': 0,
'variations': ['b'],
'clientSide': False
}
flag3 = {
'key': 'client-side-1',
'on': False,
'offVariation': 0,
'variations': ['value1'],
'clientSide': True
}
flag4 = {
'key': 'client-side-2',
'on': False,
'offVariation': 0,
'variations': ['value2'],
'clientSide': True
}
store = InMemoryFeatureStore()
store.init({
FEATURES: {
flag1['key']: flag1,
flag2['key']: flag2,
flag3['key']: flag3,
flag4['key']: flag4
}
})
client = make_client(store)
state = client.all_flags_state(user, client_side_only=True)
assert state.valid
values = state.to_values_map()
assert values == {'client-side-1': 'value1', 'client-side-2': 'value2'}
def test_event_for_existing_feature_with_no_user():
feature = make_off_flag_with_value('feature.key', 'value')
feature['trackEvents'] = True
feature['debugEventsUntilDate'] = 1000
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
with make_client(store) as client:
assert 'default' == client.variation('feature.key', None, default='default')
e = get_first_event(client)
assert (e['kind'] == 'feature' and
e['key'] == 'feature.key' and
e['user'] == None and
e['version'] == feature['version'] and
e['value'] == 'default' and
e['variation'] == None and
e['default'] == 'default' and
e['trackEvents'] == True and
e['debugEventsUntilDate'] == 1000)
def test_event_for_existing_feature_with_reason():
feature = make_off_flag_with_value('feature.key', 'value')
feature['trackEvents'] = True
feature['debugEventsUntilDate'] = 1000
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
with make_client(store) as client:
assert 'value' == client.variation_detail('feature.key', user, default='default').value
e = get_first_event(client)
assert (e['kind'] == 'feature' and
e['key'] == 'feature.key' and
e['user'] == user and
e['version'] == feature['version'] and
e['value'] == 'value' and
e['variation'] == 0 and
e['reason'] == {'kind': 'OFF'} and
e['default'] == 'default' and
e['trackEvents'] == True and
e['debugEventsUntilDate'] == 1000)
def test_all_flags_state_can_be_filtered_for_client_side_flags():
flag1 = {
'key': 'server-side-1',
'on': False,
'offVariation': 0,
'variations': [ 'a' ],
'clientSide': False
}
flag2 = {
'key': 'server-side-2',
'on': False,
'offVariation': 0,
'variations': [ 'b' ],
'clientSide': False
}
flag3 = {
'key': 'client-side-1',
'on': False,
'offVariation': 0,
'variations': [ 'value1' ],
'clientSide': True
}
flag4 = {
'key': 'client-side-2',
'on': False,
'offVariation': 0,
'variations': [ 'value2' ],
'clientSide': True
}
store = InMemoryFeatureStore()
store.init({ FEATURES: { flag1['key']: flag1, flag2['key']: flag2, flag3['key']: flag3, flag4['key']: flag4 } })
client = make_client(store)
state = client.all_flags_state(user, client_side_only=True)
assert state.valid == True
values = state.to_values_map()
assert values == { 'client-side-1': 'value1', 'client-side-2': 'value2' }
def test_variation_for_existing_feature():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
assert 'value' == client.variation('feature.key', user, default='default')
def test_all_flags_returns_none_if_user_is_none():
store = InMemoryFeatureStore()
store.init({FEATURES: {'key1': flag1, 'key2': flag2}})
client = make_client(store)
result = client.all_flags_state(None)
assert not result.valid
def test_variation_for_existing_feature():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
assert 'value' == client.variation('feature.key', user, default='default')
def test_all_flags_state_returns_empty_state_if_user_has_no_key():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
state = client.all_flags_state({ })
assert state.valid == False
def test_all_flags_returns_values():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
result = client.all_flags(user)
assert result == { 'key1': 'value1', 'key2': 'value2' }
def test_all_flags_returns_none_if_user_has_no_key():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
result = client.all_flags({ })
assert result is None
def test_all_flags_returns_none_if_user_has_no_key():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
result = client.all_flags({ })
assert result is None
def test_all_flags_returns_values():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
result = client.all_flags(user)
assert result == { 'key1': 'value1', 'key2': 'value2' }
def test_all_flags_state_returns_empty_state_if_user_has_no_key():
store = InMemoryFeatureStore()
store.init({ FEATURES: { 'key1': flag1, 'key2': flag2 } })
client = make_client(store)
state = client.all_flags_state({ })
assert state.valid == False
def test_variation_when_user_has_no_key():
feature = make_off_flag_with_value('feature.key', 'value')
store = InMemoryFeatureStore()
store.init({FEATURES: {'feature.key': feature}})
client = make_client(store)
assert 'default' == client.variation('feature.key', { }, default='default')