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()