def test_reconnects_if_stream_is_broken():
store = InMemoryFeatureStore()
ready = Event()
flagv1 = {'key': 'flagkey', 'version': 1}
flagv2 = {'key': 'flagkey', 'version': 2}
with start_server() as server:
with stream_content(make_put_event([flagv1])) as stream1:
with stream_content(make_put_event([flagv2])) as stream2:
config = Config(sdk_key='sdk-key',
stream_uri=server.uri,
initial_reconnect_delay=brief_delay)
server.for_path('/all', SequentialHandler(stream1, stream2))
with StreamingUpdateProcessor(config, store, ready,
None) as sp:
sp.start()
server.await_request
ready.wait(start_wait)
assert sp.initialized()
expect_item(store, FEATURES, flagv1)
stream1.close()
server.await_request
expect_update(store, FEATURES, flagv2)
def test_receives_patch_events():
store = InMemoryFeatureStore()
ready = Event()
flagv1 = {'key': 'flagkey', 'version': 1}
flagv2 = {'key': 'flagkey', 'version': 2}
segmentv1 = {'key': 'segkey', 'version': 1}
segmentv2 = {'key': 'segkey', 'version': 1}
with start_server() as server:
with stream_content(make_put_event([flagv1], [segmentv1])) as stream:
config = Config(sdk_key='sdk-key', stream_uri=server.uri)
server.for_path('/all', stream)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
ready.wait(start_wait)
assert sp.initialized()
expect_item(store, FEATURES, flagv1)
expect_item(store, SEGMENTS, segmentv1)
stream.push(make_patch_event(FEATURES, flagv2))
expect_update(store, FEATURES, flagv2)
stream.push(make_patch_event(SEGMENTS, segmentv2))
expect_update(store, SEGMENTS, segmentv2)
def _verify_https_proxy_is_used(server, config):
store = InMemoryFeatureStore()
ready = Event()
with stream_content(make_put_event()) as stream:
server.for_path(config.stream_base_uri + '/all', stream)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
# Our simple stub server implementation can't really do HTTPS proxying, so the request will fail, but
# it can still record that it *got* the request, which proves that the request went to the proxy.
req = server.await_request()
assert req.method == 'CONNECT'
def test_set_sdk_key_before_init():
_reset_client()
with start_server() as stream_server:
with stream_content(make_put_event()) as stream_handler:
try:
stream_server.for_path('/all', stream_handler)
ldclient.set_config(Config(sdk_key, stream_uri = stream_server.uri, send_events = False))
wait_until(ldclient.get().is_initialized, timeout=10)
r = stream_server.await_request()
assert r.headers['Authorization'] == sdk_key
finally:
_reset_client()
def _verify_http_proxy_is_used(server, config):
store = InMemoryFeatureStore()
ready = Event()
with stream_content(make_put_event()) as stream:
server.for_path(config.stream_base_uri + '/all', stream)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
# For an insecure proxy request, our stub server behaves enough like the real thing to satisfy the
# HTTP client, so we should be able to see the request go through. Note that the URI path will
# actually be an absolute URI for a proxy request.
req = server.await_request()
assert req.method == 'GET'
ready.wait(start_wait)
assert sp.initialized()
def test_sends_wrapper_header_without_version():
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
config = Config(sdk_key='sdk-key',
stream_uri=server.uri,
wrapper_name='Flask')
server.for_path('/all', stream)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
req = server.await_request()
assert req.headers.get('X-LaunchDarkly-Wrapper') == 'Flask'
def test_client_starts_in_streaming_mode():
with start_server() as stream_server:
with stream_content(make_put_event([always_true_flag
])) as stream_handler:
stream_server.for_path('/all', stream_handler)
config = Config(sdk_key=sdk_key,
stream_uri=stream_server.uri,
send_events=False)
with LDClient(config=config) as client:
assert client.is_initialized()
assert client.variation(always_true_flag['key'], user,
False) == True
r = stream_server.await_request()
assert r.headers['Authorization'] == sdk_key
def _stream_processor_proxy_test(server, config, secure):
store = InMemoryFeatureStore()
ready = Event()
with stream_content(make_put_event()) as stream:
server.for_path(config.stream_base_uri + '/all', stream)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
# Wait till the server has received a request. We need to do this even though do_proxy_tests also
# does it, because if we return too soon out of this block, the object returned by stream_content
# could be closed and the test server would no longer work.
server.wait_until_request_received()
if not secure:
# We only do this part with HTTP, because with HTTPS we don't have a real enough proxy server
# for the stream connection to work correctly - we can only detect the request.
ready.wait(start_wait)
assert sp.initialized()
def test_request_properties():
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
config = Config(sdk_key='sdk-key', stream_uri=server.uri)
server.for_path('/all', stream)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
req = server.await_request()
assert req.method == 'GET'
assert req.headers.get('Authorization') == 'sdk-key'
assert req.headers.get(
'User-Agent') == 'PythonClient/' + VERSION
assert req.headers.get('X-LaunchDarkly-Wrapper') is None
def test_unrecoverable_http_error(status):
error_handler = BasicResponse(status)
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
error_then_success = SequentialHandler(error_handler, stream)
config = Config(sdk_key='sdk-key',
stream_uri=server.uri,
initial_reconnect_delay=brief_delay)
server.for_path('/all', error_then_success)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
ready.wait(5)
assert not sp.initialized()
server.should_have_requests(1)
def test_records_diagnostic_on_stream_init_success():
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
config = Config(sdk_key='sdk-key', stream_uri=server.uri)
server.for_path('/all', stream)
diag_accum = _DiagnosticAccumulator(1)
with StreamingUpdateProcessor(config, store, ready,
diag_accum) as sp:
sp.start()
ready.wait(start_wait)
recorded_inits = diag_accum.create_event_and_reset(
0, 0)['streamInits']
assert len(recorded_inits) == 1
assert recorded_inits[0]['failed'] is False
def test_client_retries_connection_in_streaming_mode_with_non_fatal_error():
with start_server() as stream_server:
with stream_content(make_put_event([always_true_flag
])) as stream_handler:
error_then_success = SequentialHandler(BasicResponse(503),
stream_handler)
stream_server.for_path('/all', error_then_success)
config = Config(sdk_key=sdk_key,
stream_uri=stream_server.uri,
initial_reconnect_delay=0.001,
send_events=False)
with LDClient(config=config) as client:
assert client.is_initialized()
assert client.variation(always_true_flag['key'], user,
False) == True
r = stream_server.await_request()
assert r.headers['Authorization'] == sdk_key
def test_retries_on_network_error():
error_handler = CauseNetworkError()
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
two_errors_then_success = SequentialHandler(
error_handler, error_handler, stream)
config = Config(sdk_key='sdk-key',
stream_uri=server.uri,
initial_reconnect_delay=brief_delay)
server.for_path('/all', two_errors_then_success)
with StreamingUpdateProcessor(config, store, ready, None) as sp:
sp.start()
ready.wait(start_wait)
assert sp.initialized()
server.await_request
server.await_request
def test_records_diagnostic_on_stream_init_failure():
store = InMemoryFeatureStore()
ready = Event()
with start_server() as server:
with stream_content(make_put_event()) as stream:
error_then_success = SequentialHandler(BasicResponse(503), stream)
config = Config(sdk_key='sdk-key',
stream_uri=server.uri,
initial_reconnect_delay=brief_delay)
server.for_path('/all', error_then_success)
diag_accum = _DiagnosticAccumulator(1)
with StreamingUpdateProcessor(config, store, ready,
diag_accum) as sp:
sp.start()
ready.wait(start_wait)
recorded_inits = diag_accum.create_event_and_reset(
0, 0)['streamInits']
assert len(recorded_inits) == 2
assert recorded_inits[0]['failed'] is True
assert recorded_inits[1]['failed'] is False
def test_set_sdk_key_after_init():
_reset_client()
other_key = 'other-key'
with start_server() as stream_server:
with stream_content(make_put_event()) as stream_handler:
try:
stream_server.for_path('/all', BasicResponse(401))
config = Config(other_key, stream_uri = stream_server.uri, send_events = False)
ldclient.set_config(config)
assert ldclient.get().is_initialized() is False
r = stream_server.await_request()
assert r.headers['Authorization'] == other_key
stream_server.for_path('/all', stream_handler)
ldclient.set_config(config.copy_with_new_sdk_key(sdk_key))
wait_until(ldclient.get().is_initialized, timeout=30)
r = stream_server.await_request()
assert r.headers['Authorization'] == sdk_key
finally:
_reset_client()
