def _put_impressions(self, adapter, metadata):
storage = RedisImpressionsStorage(adapter, metadata)
storage.put([
impressions.Impression('key1', 'feature1', 'on', 'l1', 123456, 'b1', 321654),
impressions.Impression('key2', 'feature1', 'on', 'l1', 123456, 'b1', 321654),
impressions.Impression('key3', 'feature1', 'on', 'l1', 123456, 'b1', 321654)
])
def test_wrap_impressions(self, mocker):
"""Test wrap impressions."""
adapter = mocker.Mock(spec=RedisAdapter)
metadata = get_metadata({})
storage = RedisImpressionsStorage(adapter, metadata)
impressions = [
Impression('key1', 'feature1', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key2', 'feature2', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key3', 'feature2', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key4', 'feature1', 'on', 'some_label', 123456, 'buck1',
321654)
]
to_validate = [json.dumps({
'm': { # METADATA PORTION
's': metadata.sdk_version,
'n': metadata.instance_name,
'i': metadata.instance_ip,
},
'i': { # IMPRESSION PORTION
'k': impression.matching_key,
'b': impression.bucketing_key,
'f': impression.feature_name,
't': impression.treatment,
'r': impression.label,
'c': impression.change_number,
'm': impression.time,
}
}) for impression in impressions]
assert storage._wrap_impressions(impressions) == to_validate
def test_add_impressions(self, mocker):
"""Test that adding impressions to storage works."""
adapter = mocker.Mock(spec=RedisAdapter)
metadata = get_metadata({})
storage = RedisImpressionsStorage(adapter, metadata)
impressions = [
Impression('key1', 'feature1', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key2', 'feature2', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key3', 'feature2', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key4', 'feature1', 'on', 'some_label', 123456, 'buck1',
321654)
]
assert storage.put(impressions) is True
to_validate = [json.dumps({
'm': { # METADATA PORTION
's': metadata.sdk_version,
'n': metadata.instance_name,
'i': metadata.instance_ip,
},
'i': { # IMPRESSION PORTION
'k': impression.matching_key,
'b': impression.bucketing_key,
'f': impression.feature_name,
't': impression.treatment,
'r': impression.label,
'c': impression.change_number,
'm': impression.time,
}
}) for impression in impressions]
assert adapter.rpush.mock_calls == [
mocker.call('SPLITIO.impressions', *to_validate)
]
# Assert that if an exception is thrown it's caught and False is returned
adapter.reset_mock()
def _raise_exc(*_):
raise RedisAdapterException('something')
adapter.rpush.side_effect = _raise_exc
assert storage.put(impressions) is False
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 test_put_fetch_contains(self):
"""Test storing and retrieving splits in redis."""
adapter = _build_default_client({})
try:
metadata = get_metadata({})
storage = RedisImpressionsStorage(adapter, metadata)
storage.put([
impressions.Impression('key1', 'feature1', 'on', 'l1', 123456,
'b1', 321654),
impressions.Impression('key2', 'feature1', 'on', 'l1', 123456,
'b1', 321654),
impressions.Impression('key3', 'feature1', 'on', 'l1', 123456,
'b1', 321654)
])
imps = adapter.lrange('SPLITIO.impressions', 0, 2)
assert len(imps) == 3
finally:
adapter.delete('SPLITIO.impressions')
def test_add_impressions_to_pipe(self, mocker):
"""Test that adding impressions to storage works."""
adapter = mocker.Mock(spec=RedisAdapter)
metadata = get_metadata({})
storage = RedisImpressionsStorage(adapter, metadata)
impressions = [
Impression('key1', 'feature1', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key2', 'feature2', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key3', 'feature2', 'on', 'some_label', 123456, 'buck1',
321654),
Impression('key4', 'feature1', 'on', 'some_label', 123456, 'buck1',
321654)
]
to_validate = [json.dumps({
'm': { # METADATA PORTION
's': metadata.sdk_version,
'n': metadata.instance_name,
'i': metadata.instance_ip,
},
'i': { # IMPRESSION PORTION
'k': impression.matching_key,
'b': impression.bucketing_key,
'f': impression.feature_name,
't': impression.treatment,
'r': impression.label,
'c': impression.change_number,
'm': impression.time,
}
}) for impression in impressions]
storage.add_impressions_to_pipe(impressions, adapter)
assert adapter.rpush.mock_calls == [
mocker.call('SPLITIO.impressions', *to_validate)
]
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 setup_method(self):
"""Prepare storages with test data."""
metadata = SdkMetadata('python-1.2.3', 'some_ip', 'some_name')
redis_client = RedisAdapter(StrictRedis())
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'])
self.factory = SplitFactory(
'some_api_key',
{ #pylint:disable=attribute-defined-outside-init
'splits': split_storage,
'segments': segment_storage,
'impressions': RedisImpressionsStorage(redis_client, metadata),
'events': RedisEventsStorage(redis_client, metadata),
'telemetry': RedisTelemetryStorage(redis_client, metadata)
},
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),
'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))
)