def test_store_data_set_ordering():
store = CapturingFeatureStore()
config = Config(
sdk_key='SDK_KEY',
send_events=False,
feature_store=store,
update_processor_class=DependencyOrderingDataUpdateProcessor)
LDClient(config=config)
data = store.received_data
assert data is not None
assert len(data) == 2
keys = list(data.keys())
values = list(data.values())
assert keys[0] == SEGMENTS
assert len(values[0]) == len(dependency_ordering_test_data[SEGMENTS])
assert keys[1] == FEATURES
flags_map = values[1]
flags_list = list(flags_map.values())
assert len(flags_list) == len(dependency_ordering_test_data[FEATURES])
for item_index, item in enumerate(flags_list):
for prereq in item.get("prerequisites", []):
prereq_item = flags_map[prereq["key"]]
prereq_index = flags_list.index(prereq_item)
if prereq_index > item_index:
all_keys = (f["key"] for f in flags_list)
raise Exception(
"%s depends on %s, but %s was listed first; keys in order are [%s]"
% (item["key"], prereq["key"], item["key"],
", ".join(all_keys)))
def test_client_has_null_event_processor_if_send_events_off():
config = Config(sdk_key="secret",
base_uri=unreachable_uri,
update_processor_class=MockUpdateProcessor,
send_events=False)
with LDClient(config=config) as client:
assert isinstance(client._event_processor, NullEventProcessor)
def test_defaults():
config = Config("SDK_KEY",
base_uri="http://localhost:3000",
defaults={"foo": "bar"},
offline=True)
with LDClient(config=config) as client:
assert "bar" == client.variation('foo', user, default=None)
def test_defaults_and_online_no_default():
client = LDClient(config=Config(base_uri="http://localhost:3000",
defaults={"foo": "bar"},
event_consumer_class=MockConsumer,
feature_requester_class=MockFeatureRequester))
assert "jim" == client.variation('baz', user, default="jim")
assert wait_for_event(client, lambda e: e['kind'] == 'feature' and e['key'] == u'baz' and e['user'] == user)
def test_client_has_streaming_processor_by_default():
config = Config(sdk_key="secret",
base_uri=unreachable_uri,
stream_uri=unreachable_uri,
send_events=False)
with LDClient(config=config, start_wait=0) as client:
assert isinstance(client._update_processor, StreamingUpdateProcessor)
def test_client_has_polling_processor_if_streaming_is_disabled():
config = Config(sdk_key="secret",
stream=False,
base_uri=unreachable_uri,
stream_uri=unreachable_uri,
send_events=False)
with LDClient(config=config, start_wait=0) as client:
assert isinstance(client._update_processor, PollingUpdateProcessor)
def make_client(store = InMemoryFeatureStore()):
return LDClient(config=Config(sdk_key = 'SDK_KEY',
base_uri=unreachable_uri,
events_uri=unreachable_uri,
stream_uri=unreachable_uri,
event_processor_class=MockEventProcessor,
update_processor_class=MockUpdateProcessor,
feature_store=store))
def test_sse_init(stream):
stream.queue.put(Event(event="put", data=feature("foo", "jim")))
client = LDClient(
"apikey",
Config(feature_requester_class=partial(create_redis_ldd_requester,
expiration=0),
events=False))
wait_until(lambda: client.toggle("foo", user('xyz'), "blah") == "jim",
timeout=10)
def test_defaults_and_online_no_default():
my_client = LDClient(
config=Config(base_uri="http://localhost:3000",
defaults={"foo": "bar"},
event_processor_class=MockEventProcessor,
update_processor_class=MockUpdateProcessor))
assert "jim" == my_client.variation('baz', user, default="jim")
e = get_first_event(my_client)
assert e['kind'] == 'feature' and e['key'] == u'baz' and e['user'] == user
def test_defaults_and_online():
expected = "bar"
my_client = LDClient(config=Config(base_uri="http://localhost:3000",
defaults={"foo": expected},
event_consumer_class=MockConsumer,
feature_requester_class=MockFeatureRequester,
feature_store=InMemoryFeatureStore()))
actual = my_client.variation('foo', user, default="originalDefault")
assert actual == expected
assert wait_for_event(my_client, lambda e: e['kind'] == 'feature' and e['key'] == u'foo' and e['user'] == user)
def test_defaults_and_online():
expected = "bar"
my_client = LDClient(
config=Config(base_uri="http://localhost:3000",
defaults={"foo": expected},
event_processor_class=MockEventProcessor,
update_processor_class=MockUpdateProcessor,
feature_store=InMemoryFeatureStore()))
actual = my_client.variation('foo', user, default="originalDefault")
assert actual == expected
e = get_first_event(my_client)
assert e['kind'] == 'feature' and e['key'] == u'foo' and e['user'] == user
def test_exception_in_retrieval():
class ExceptionFeatureRequester(FeatureRequester):
def __init__(self, *_):
pass
def get(self, key, callback):
raise Exception("blah")
client = LDClient("API_KEY", Config("http://localhost:3000", defaults={"foo": "bar"},
feature_requester_class=ExceptionFeatureRequester,
consumer_class=MockConsumer))
assert "bar" == client.toggle('foo', user, default="jim")
assert wait_for_event(client, lambda e: e['kind'] == 'feature' and e['key'] == u'foo' and e['user'] == user)
def test_exception_in_retrieval():
class ExceptionFeatureRequester(FeatureRequester):
def __init__(self, *_):
pass
def get_all(self):
raise Exception("blah")
client = LDClient(config=Config(base_uri="http://localhost:3000",
defaults={"foo": "bar"},
feature_store=InMemoryFeatureStore(),
feature_requester_class=ExceptionFeatureRequester,
event_consumer_class=MockConsumer))
assert "bar" == client.variation('foo', user, default="jim")
assert wait_for_event(client, lambda e: e['kind'] == 'feature' and e['key'] == u'foo' and e['user'] == user)
def make_ldd_client():
return LDClient(config=Config(sdk_key="secret",
use_ldd=True,
base_uri=unreachable_uri,
events_uri=unreachable_uri,
stream_uri=unreachable_uri))
u'variations': [{
u'value': True,
u'weight': 100,
u'targets': []
}, {
u'value': False,
u'weight': 0,
u'targets': []
}]
}
else:
return None
client = LDClient(config=Config(base_uri="http://localhost:3000",
feature_store=MockFeatureStore(),
update_processor_class=MockUpdateProcessor))
offline_client = LDClient(config=Config(sdk_key="secret",
base_uri="http://localhost:3000",
feature_store=MockFeatureStore(),
offline=True))
no_send_events_client = LDClient(
config=Config(sdk_key="secret",
base_uri="http://localhost:3000",
feature_store=MockFeatureStore(),
send_events=False,
update_processor_class=MockUpdateProcessor))
user = {u'key': u'xyz', u'custom': {u'bizzle': u'def'}}
numeric_key_user = {}
def test_toggle(server):
server.add_feature("foo", feature("foo", "jim")['foo'])
client = LDClient("apikey", Config(base_uri=server.url))
wait_until(lambda: client.toggle("foo", user('xyz'), "blah") == "jim")
def make_client(store):
return LDClient(config=Config(sdk_key='SDK_KEY',
base_uri="http://localhost:3000",
event_processor_class=MockEventProcessor,
update_processor_class=MockUpdateProcessor,
feature_store=store))
from ldclient.client import LDClient, Config
from ldclient.event_processor import NullEventProcessor
from ldclient.feature_store import InMemoryFeatureStore
from ldclient.interfaces import UpdateProcessor
from ldclient.versioned_data_kind import FEATURES, SEGMENTS
import pytest
from testing.stub_util import CapturingFeatureStore, MockEventProcessor, MockUpdateProcessor
from testing.sync_util import wait_until
try:
import queue
except:
import Queue as queue
client = LDClient(config=Config(base_uri="http://localhost:3000",
event_processor_class=MockEventProcessor,
update_processor_class=MockUpdateProcessor))
offline_client = LDClient(config=Config(
sdk_key="secret", base_uri="http://localhost:3000", offline=True))
no_send_events_client = LDClient(
config=Config(sdk_key="secret",
base_uri="http://localhost:3000",
update_processor_class=MockUpdateProcessor,
send_events=False))
user = {u'key': u'xyz', u'custom': {u'bizzle': u'def'}}
def make_client(store):
return LDClient(config=Config(sdk_key='SDK_KEY',
base_uri="http://localhost:3000",
def test_sse_init(server, stream):
stream.queue.put(Event(event="put", data=feature("foo", "jim")))
client = LDClient(
"apikey",
Config(stream=True, base_uri=server.url, stream_uri=stream.url))
wait_until(lambda: client.toggle("foo", user('xyz'), "blah") == "jim")
u'variations': [{
u'value': True,
u'weight': 100,
u'targets': []
}, {
u'value': False,
u'weight': 0,
u'targets': []
}]
}
else:
return None
client = LDClient(
"SDK_KEY", Config("http://localhost:3000",
feature_store=MockFeatureStore()))
offline_client = LDClient(
"secret",
Config("http://localhost:3000",
feature_store=MockFeatureStore(),
offline=True))
user = {u'key': u'xyz', u'custom': {u'bizzle': u'def'}}
numeric_key_user = {}
sanitized_numeric_key_user = {u'key': '33', u'custom': {u'bizzle': u'def'}}
class MockConsumer(object):
def __init__(self, *_):
from builtins import object
import json
from ldclient.client import Config
from ldclient.user_filter import UserFilter
base_config = Config()
config_with_all_attrs_private = Config(all_attributes_private=True)
config_with_some_attrs_private = Config(
private_attribute_names=[u'firstName', u'bizzle'])
# users to serialize
user = {
u'key': u'abc',
u'firstName': u'Sue',
u'custom': {
u'bizzle': u'def',
u'dizzle': u'ghi'
}
}
user_specifying_own_private_attr = {
u'key': u'abc',
u'firstName': u'Sue',
u'custom': {
u'bizzle': u'def',
u'dizzle': u'ghi'
},
u'privateAttributeNames': [u'dizzle', u'unused']
}
import json
from ldclient.client import Config
from ldclient.user_filter import UserFilter
base_config = Config("fake_sdk_key")
config_with_all_attrs_private = Config("fake_sdk_key", all_attributes_private = True)
config_with_some_attrs_private = Config("fake_sdk_key", private_attribute_names=set([u'firstName', u'bizzle']))
# users to serialize
user = {
u'key': u'abc',
u'firstName': u'Sue',
u'custom': {
u'bizzle': u'def',
u'dizzle': u'ghi'
}
}
user_specifying_own_private_attr = {
u'key': u'abc',
u'firstName': u'Sue',
u'custom': {
u'bizzle': u'def',
u'dizzle': u'ghi'
},
u'privateAttributeNames': [ u'dizzle', u'unused' ]
}
user_with_unknown_top_level_attrs = {
def test_defaults_and_online_no_default():
client = LDClient("API_KEY", Config("http://localhost:3000", defaults={"foo": "bar"},
feature_requester_class=MockFeatureRequester,
consumer_class=MockConsumer))
assert "jim" == client.toggle('baz', user, default="jim")
assert wait_for_event(client, lambda e: e['kind'] == 'feature' and e['key'] == u'baz' and e['user'] == user)
def test_defaults():
client = LDClient("API_KEY", Config("http://localhost:3000", defaults={"foo": "bar"}))
client.set_offline()
assert "bar" == client.toggle('foo', user, default=None)
u'value': True,
u'weight': 100,
u'targets': []
},
{
u'value': False,
u'weight': 0,
u'targets': []
}
]
}
else:
return None
client = LDClient(config=Config(base_uri="http://localhost:3000", feature_store=MockFeatureStore()))
offline_client = LDClient(config=
Config(sdk_key="secret", base_uri="http://localhost:3000", feature_store=MockFeatureStore(),
offline=True))
user = {
u'key': u'xyz',
u'custom': {
u'bizzle': u'def'
}
}
numeric_key_user = {}
sanitized_numeric_key_user = {
u'key': '33',
def test_ctor_both_sdk_keys_set():
with pytest.raises(Exception):
config = Config(sdk_key="sdk key a", offline=True)
LDClient(sdk_key="sdk key b", config=config)
def test_defaults():
client = LDClient(config=Config(base_uri="http://localhost:3000",
defaults={"foo": "bar"},
offline=True))
assert "bar" == client.variation('foo', user, default=None)
u'value': True,
u'weight': 100,
u'targets': []
},
{
u'value': False,
u'weight': 0,
u'targets': []
}
]
})
else:
return callback(None)
client = LDClient("API_KEY", Config("http://localhost:3000",
feature_requester_class=MockFeatureRequester))
user = {
u'key': u'xyz',
u'custom': {
u'bizzle': u'def'
}
}
class MockConsumer(object):
def __init__(self, *_):
self._running = False
def stop(self):
self._running = False
