def test_sentinel_ssl_fails(self):
"""Test that SSL/TLS & Sentinel don't return a valid client."""
with pytest.raises(redis.SentinelConfigurationException) as exc:
redis.build({
'redisSentinels': ['a', 'b'],
'redisSsl': True,
})
def _build_redis_factory(api_key, cfg):
"""Build and return a split factory with redis-based storage."""
sdk_metadata = util.get_metadata(cfg)
redis_adapter = redis.build(cfg)
cache_enabled = cfg.get('redisLocalCacheEnabled', False)
cache_ttl = cfg.get('redisLocalCacheTTL', 5)
storages = {
'splits': RedisSplitStorage(redis_adapter, cache_enabled, cache_ttl),
'segments': RedisSegmentStorage(redis_adapter),
'impressions': RedisImpressionsStorage(redis_adapter, sdk_metadata),
'events': RedisEventsStorage(redis_adapter, sdk_metadata),
}
data_sampling = cfg.get('dataSampling', DEFAULT_DATA_SAMPLING)
if data_sampling < _MIN_DEFAULT_DATA_SAMPLING_ALLOWED:
_LOGGER.warning("dataSampling cannot be less than %.2f, defaulting to minimum",
_MIN_DEFAULT_DATA_SAMPLING_ALLOWED)
data_sampling = _MIN_DEFAULT_DATA_SAMPLING_ALLOWED
recorder = PipelinedRecorder(
redis_adapter.pipeline,
ImpressionsManager(cfg['impressionsMode'], False,
_wrap_impression_listener(cfg['impressionListener'], sdk_metadata)),
storages['events'],
storages['impressions'],
data_sampling,
)
return SplitFactory(
api_key,
storages,
cfg['labelsEnabled'],
recorder,
)
def _build_redis_factory(config):
"""Build and return a split factory with redis-based storage."""
cfg = DEFAULT_CONFIG.copy()
cfg.update(config)
sdk_metadata = util.get_metadata(config)
redis_adapter = redis.build(config)
storages = {
'splits': RedisSplitStorage(redis_adapter),
'segments': RedisSegmentStorage(redis_adapter),
'impressions': RedisImpressionsStorage(redis_adapter, sdk_metadata),
'events': RedisEventsStorage(redis_adapter, sdk_metadata),
'telemetry': RedisTelemetryStorage(redis_adapter, sdk_metadata)
}
return SplitFactory(storages,
cfg['labelsEnabled'],
impression_listener=_wrap_impression_listener(
cfg['impressionListener'], sdk_metadata))
def setup_method(self):
"""Prepare storages with test data."""
metadata = SdkMetadata('python-1.2.3', 'some_ip', 'some_name')
redis_client = build(DEFAULT_CONFIG.copy())
split_storage = RedisSplitStorage(redis_client, True)
segment_storage = RedisSegmentStorage(redis_client)
split_fn = os.path.join(os.path.dirname(__file__), 'files',
'splitChanges.json')
with open(split_fn, 'r') as flo:
data = json.loads(flo.read())
for split in data['splits']:
redis_client.set(split_storage._get_key(split['name']),
json.dumps(split))
redis_client.set(split_storage._SPLIT_TILL_KEY, data['till'])
segment_fn = os.path.join(os.path.dirname(__file__), 'files',
'segmentEmployeesChanges.json')
with open(segment_fn, 'r') as flo:
data = json.loads(flo.read())
redis_client.sadd(segment_storage._get_key(data['name']),
*data['added'])
redis_client.set(segment_storage._get_till_key(data['name']),
data['till'])
segment_fn = os.path.join(os.path.dirname(__file__), 'files',
'segmentHumanBeignsChanges.json')
with open(segment_fn, 'r') as flo:
data = json.loads(flo.read())
redis_client.sadd(segment_storage._get_key(data['name']),
*data['added'])
redis_client.set(segment_storage._get_till_key(data['name']),
data['till'])
storages = {
'splits': split_storage,
'segments': segment_storage,
'impressions': RedisImpressionsStorage(redis_client, metadata),
'events': RedisEventsStorage(redis_client, metadata),
}
impmanager = ImpressionsManager(storages['impressions'].put,
ImpressionsMode.DEBUG)
recorder = PipelinedRecorder(redis_client.pipeline, impmanager,
storages['events'],
storages['impressions'])
self.factory = SplitFactory('some_api_key', storages, True, recorder) # pylint:disable=attribute-defined-outside-init
def _build_redis_factory(api_key, cfg):
"""Build and return a split factory with redis-based storage."""
sdk_metadata = util.get_metadata(cfg)
redis_adapter = redis.build(cfg)
cache_enabled = cfg.get('redisLocalCacheEnabled', False)
cache_ttl = cfg.get('redisLocalCacheTTL', 5)
storages = {
'splits': RedisSplitStorage(redis_adapter, cache_enabled, cache_ttl),
'segments': RedisSegmentStorage(redis_adapter),
'impressions': RedisImpressionsStorage(redis_adapter, sdk_metadata),
'events': RedisEventsStorage(redis_adapter, sdk_metadata),
'telemetry': RedisTelemetryStorage(redis_adapter, sdk_metadata)
}
return SplitFactory(
api_key,
storages,
cfg['labelsEnabled'],
ImpressionsManager(storages['impressions'].put, cfg['impressionsMode'], False,
_wrap_impression_listener(cfg['impressionListener'], sdk_metadata))
)
def test_adapter_building(self, mocker):
"""Test buildin different types of client according to parameters received."""
strict_redis_mock = mocker.Mock(spec=StrictRedis)
sentinel_mock = mocker.Mock(spec=Sentinel)
mocker.patch('splitio.storage.adapters.redis.StrictRedis',
new=strict_redis_mock)
mocker.patch('splitio.storage.adapters.redis.Sentinel',
new=sentinel_mock)
config = {
'redisHost': 'some_host',
'redisPort': 1234,
'redisDb': 0,
'redisPassword': '******',
'redisSocketTimeout': 123,
'redisSocketConnectTimeout': 456,
'redisSocketKeepalive': 789,
'redisSocketKeepaliveOptions': 10,
'redisConnectionPool': 20,
'redisUnixSocketPath': '/tmp/socket',
'redisEncoding': 'utf-8',
'redisEncodingErrors': 'strict',
'redisCharset': 'ascii',
'redisErrors': 'abc',
'redisDecodeResponses': True,
'redisRetryOnTimeout': True,
'redisSsl': True,
'redisSslKeyfile': '/ssl.cert',
'redisSslCertfile': '/ssl2.cert',
'redisSslCertReqs': 'abc',
'redisSslCaCerts': 'def',
'redisMaxConnections': 5,
'redisPrefix': 'some_prefix'
}
redis.build(config)
assert strict_redis_mock.mock_calls[0] == mocker.call(
host='some_host',
port=1234,
db=0,
password='******',
socket_timeout=123,
socket_connect_timeout=456,
socket_keepalive=789,
socket_keepalive_options=10,
connection_pool=20,
unix_socket_path='/tmp/socket',
encoding='utf-8',
encoding_errors='strict',
charset='ascii',
errors='abc',
decode_responses=True,
retry_on_timeout=True,
ssl=True,
ssl_keyfile='/ssl.cert',
ssl_certfile='/ssl2.cert',
ssl_cert_reqs='abc',
ssl_ca_certs='def',
max_connections=5)
config = {
'redisSentinels': [('123.123.123.123', 1), ('456.456.456.456', 2),
('789.789.789.789', 3)],
'redisMasterService':
'some_master',
'redisDb':
0,
'redisPassword':
'******',
'redisSocketTimeout':
123,
'redisSocketConnectTimeout':
456,
'redisSocketKeepalive':
789,
'redisSocketKeepaliveOptions':
10,
'redisConnectionPool':
20,
'redisUnixSocketPath':
'/tmp/socket',
'redisEncoding':
'utf-8',
'redisEncodingErrors':
'strict',
'redisCharset':
'ascii',
'redisErrors':
'abc',
'redisDecodeResponses':
True,
'redisRetryOnTimeout':
True,
'redisSsl':
False,
'redisSslKeyfile':
'/ssl.cert',
'redisSslCertfile':
'/ssl2.cert',
'redisSslCertReqs':
'abc',
'redisSslCaCerts':
'def',
'redisMaxConnections':
5,
'redisPrefix':
'some_prefix'
}
redis.build(config)
assert sentinel_mock.mock_calls[0] == mocker.call(
[('123.123.123.123', 1), ('456.456.456.456', 2),
('789.789.789.789', 3)],
db=0,
password='******',
socket_timeout=123,
socket_connect_timeout=456,
socket_keepalive=789,
socket_keepalive_options=10,
connection_pool=20,
encoding='utf-8',
encoding_errors='strict',
decode_responses=True,
retry_on_timeout=True,
max_connections=5)
