def setUp(self):
self.some_feature = 'feature_0'
self.some_other_feature = 'feature_1'
self.some_impression_0 = Impression(matching_key=mock.MagicMock(),
feature_name=self.some_feature,
treatment=mock.MagicMock(),
label=mock.MagicMock(),
change_number=mock.MagicMock(),
bucketing_key=mock.MagicMock(),
time=mock.MagicMock())
self.some_impression_1 = Impression(
matching_key=mock.MagicMock(),
feature_name=self.some_other_feature,
treatment=mock.MagicMock(),
label=mock.MagicMock(),
change_number=mock.MagicMock(),
bucketing_key=mock.MagicMock(),
time=mock.MagicMock())
self.some_impression_2 = Impression(
matching_key=mock.MagicMock(),
feature_name=self.some_other_feature,
treatment=mock.MagicMock(),
label=mock.MagicMock(),
change_number=mock.MagicMock(),
bucketing_key=mock.MagicMock(),
time=mock.MagicMock())
def setUp(self):
self._some_config = mock.MagicMock()
self._split_changes_file_name = join(
dirname(__file__), 'splitCustomImpressionListener.json')
with open(self._split_changes_file_name) as f:
self._json = load(f)
split_definition = self._json['splits'][0]
split_name = split_definition['name']
self._redis = get_redis(
{'redisPrefix': 'customImpressionListenerTest'})
self._redis_split_cache = RedisSplitCache(self._redis)
self._redis_split_cache.add_split(split_name, split_definition)
self._client = Client(RedisBroker(self._redis, self._some_config))
self.some_feature = 'feature_0'
self.some_impression_0 = Impression(matching_key=mock.MagicMock(),
feature_name=self.some_feature,
treatment=mock.MagicMock(),
label=mock.MagicMock(),
change_number=mock.MagicMock(),
bucketing_key=mock.MagicMock(),
time=mock.MagicMock())
def fetch_all_and_clear(self):
"""Fetches all impressions from the cache and clears it. It returns a dictionary with the
impressions grouped by feature name.
:return: All cached impressions so far grouped by feature name
:rtype: dict
"""
features = self._adapter.cache_get(UWSGISplitCache._KEY_FEATURE_LIST,
_SPLITIO_MISC_NAMESPACE)
try:
features = decode(features)
except TypeError:
features = set()
# Include impressions for splits not in cache.
features.add(self._MISSING)
impressions = []
for feature in features:
key = self._IMPRESSIONS_KEY.format(feature=feature)
lock_key = self._LOCK_IMPRESSION_KEY.format(feature=feature)
with UWSGILock(lock_key):
raw = self._adapter.cache_get(
key, _SPLITIO_IMPRESSIONS_CACHE_NAMESPACE)
self._adapter.cache_del(key,
_SPLITIO_IMPRESSIONS_CACHE_NAMESPACE)
try:
impressions.extend([Impression(*i) for i in decode(raw)])
except TypeError:
pass
return self._build_impressions_dict(impressions)
def setUp(self):
self.some_key = mock.MagicMock()
self.some_feature_name = mock.MagicMock()
self.some_treatment = mock.MagicMock()
self.some_time = mock.MagicMock()
self.deepcopy_mock = self.patch('splitio.impressions.deepcopy')
self.defaultdict_mock_side_effect = [
mock.MagicMock(), # during __init__
mock.MagicMock() # afterwards
]
self.defaultdict_mock = self.patch(
'splitio.impressions.defaultdict',
side_effect=self.defaultdict_mock_side_effect)
self.rlock_mock = self.patch('splitio.impressions.RLock')
self.treatment_log = InMemoryTreatmentLog()
self.notify_eviction_mock = self.patch_object(self.treatment_log,
'_notify_eviction')
self.some_label = mock.MagicMock()
self.some_change_number = mock.MagicMock()
self.some_impression = Impression(
matching_key=self.some_key,
feature_name=self.some_feature_name,
treatment=self.some_treatment,
label=self.some_label,
change_number=self.some_change_number,
bucketing_key=self.some_key,
time=self.some_time)
def fetch_all(self):
'''
Fetches all impressions from the cache. It returns a dictionary with the
impressions grouped by feature name.
:return: All cached impressions so far grouped by feature name
:rtype: dict
'''
impressions_list = list()
impressions_keys = self._redis.keys(self._get_impressions_key('*'))
for impression_key in impressions_keys:
impression_key = bytes_to_string(impression_key)
if (impression_key.replace(self._get_impressions_key(''),
'') == 'impressions'):
continue
feature_name = impression_key.replace(
self._get_impressions_key(''), '')
for impression in self._redis.smembers(impression_key):
impression = bytes_to_string(impression)
impression_decoded = decode(impression)
impression_tuple = Impression(
key=impression_decoded['keyName'],
feature_name=feature_name,
treatment=impression_decoded['treatment'],
time=impression_decoded['time'])
impressions_list.append(impression_tuple)
if not impressions_list:
return dict()
return self._build_impressions_dict(impressions_list)
def _build_impression(self, feature_name):
return Impression(matching_key=mock.MagicMock(),
feature_name=feature_name,
treatment=mock.MagicMock(),
label=mock.MagicMock(),
time=mock.MagicMock(),
change_number=mock.MagicMock(),
bucketing_key=mock.MagicMock())
def setUp(self):
self._impression_1 = Impression(matching_key='matching_key',
feature_name='feature_name_1',
treatment='treatment',
label='label',
change_number='change_number',
bucketing_key='bucketing_key',
time=1325599980)
self._impression_2 = Impression(matching_key='matching_key',
feature_name='feature_name_2',
treatment='treatment',
label='label',
change_number='change_number',
bucketing_key='bucketing_key',
time=1325599980)
self.impression_cache = UWSGIImpressionsCache(get_uwsgi(emulator=True))
def fetch_all_and_clear(self):
'''
Fetches all impressions from the cache and clears it.
It returns a dictionary with the impressions grouped by feature name.
:return: All cached impressions so far grouped by feature name
:rtype: dict
'''
impressions_list = list()
impressions_keys = self._redis.keys(self._get_impressions_key('*'))
for impression_key in impressions_keys:
impression_key = bytes_to_string(impression_key)
if (impression_key.replace(self._get_impressions_key(''),
'') == 'impressions'):
continue
feature_name = impression_key.replace(
self._get_impressions_key(''), '')
to_remove = list()
for impression in self._redis.smembers(impression_key):
to_remove.append(impression)
impression = bytes_to_string(impression)
impression_decoded = decode(impression)
label = ''
if 'label' in impression_decoded:
label = impression_decoded['label']
change_number = -1
if 'changeNumber' in impression_decoded:
change_number = impression_decoded['changeNumber']
bucketing_key = ''
if 'bucketingKey' in impression_decoded:
bucketing_key = impression_decoded['bucketingKey']
impression_tuple = Impression(
matching_key=impression_decoded['keyName'],
feature_name=feature_name,
treatment=impression_decoded['treatment'],
label=label,
change_number=change_number,
bucketing_key=bucketing_key,
time=impression_decoded['time'])
impressions_list.append(impression_tuple)
self._redis.srem(impression_key, *set(to_remove))
if not impressions_list:
return dict()
return self._build_impressions_dict(impressions_list)
def test_log_doesnt_call_internal_log_if_feature_name_is_none(self):
"""Tests that log doesn't call _log if feature name is None"""
impression = Impression(matching_key=self.some_key,
feature_name=None,
treatment=self.some_treatment,
label=self.some_label,
change_number=self.some_change_number,
bucketing_key=self.some_key,
time=self.some_time)
self.treatment_log.log(impression)
self.log_mock.assert_not_called()
def _build_impression(self, matching_key, feature_name, treatment, label,
change_number, bucketing_key, time):
if not self._labels_enabled:
label = None
return Impression(matching_key=matching_key,
feature_name=feature_name,
treatment=treatment,
label=label,
change_number=change_number,
bucketing_key=bucketing_key,
time=time)
def setUp(self):
self.some_key = mock.MagicMock()
self.some_feature_name = mock.MagicMock()
self.some_treatment = mock.MagicMock()
self.some_time = 123456
self.treatment_log = TreatmentLog()
self.log_mock = self.patch_object(self.treatment_log, '_log')
self.some_label = mock.MagicMock()
self.some_change_number = mock.MagicMock()
self.some_impression = Impression(
matching_key=self.some_key,
feature_name=self.some_feature_name,
treatment=self.some_treatment,
label=self.some_label,
change_number=self.some_change_number,
bucketing_key=self.some_key,
time=self.some_time)
def setUp(self):
self.some_key = mock.MagicMock()
self.some_feature_name = mock.MagicMock()
self.some_treatment = mock.MagicMock()
self.some_time = mock.MagicMock()
self.some_impressions_cache = mock.MagicMock()
self.treatment_log = CacheBasedTreatmentLog(
self.some_impressions_cache)
self.some_label = mock.MagicMock()
self.some_change_number = mock.MagicMock()
self.some_impression = Impression(
matching_key=self.some_key,
feature_name=self.some_feature_name,
treatment=self.some_treatment,
label=self.some_label,
change_number=self.some_change_number,
bucketing_key=self.some_key,
time=self.some_time)
def setUp(self):
self.some_key = mock.MagicMock()
self.some_feature_name = mock.MagicMock()
self.some_treatment = mock.MagicMock()
self.some_time = mock.MagicMock()
self.logger_mock = self.patch(
'splitio.impressions.logging.getLogger').return_value
self.treatment_log = LoggerBasedTreatmentLog()
self.some_label = mock.MagicMock()
self.some_change_number = mock.MagicMock()
self.some_impression = Impression(
matching_key=self.some_key,
feature_name=self.some_feature_name,
treatment=self.some_treatment,
label=self.some_label,
change_number=self.some_change_number,
bucketing_key=self.some_key,
time=self.some_time)
def fetch_all_and_clear(self):
"""Fetches all impressions from the cache and clears it. It returns a dictionary with the
impressions grouped by feature name.
:return: All cached impressions so far grouped by feature name
:rtype: dict
"""
if self._adapter.cache_exists(self._IMPRESSIONS_KEY,
_SPLITIO_STATS_CACHE_NAMESPACE):
impressions_list = list()
self.__lock_impressions()
cached_impressions = decode(
self._adapter.cache_get(self._IMPRESSIONS_KEY,
_SPLITIO_STATS_CACHE_NAMESPACE))
self._adapter.cache_del(self._IMPRESSIONS_KEY,
_SPLITIO_STATS_CACHE_NAMESPACE)
self.__unlock_impressions()
_logger.debug('**** Cached Impressions: %s' % cached_impressions)
for feature_name in cached_impressions:
impressions = cached_impressions[feature_name]
for impression in impressions:
impression_tuple = Impression(
matching_key=impression['keyName'],
feature_name=feature_name,
treatment=impression['treatment'],
label=impression['label'],
change_number=impression['changeNumber'],
bucketing_key=impression['bucketingKey'],
time=impression['time'])
impressions_list.append(impression_tuple)
if not impressions_list:
return dict()
return self._build_impressions_dict(impressions_list)
return dict()
def setUp(self):
self.some_key = mock.MagicMock()
self.some_feature_name = mock.MagicMock()
self.some_treatment = mock.MagicMock()
self.some_label = mock.MagicMock()
self.some_change_number = mock.MagicMock()
self.some_time = mock.MagicMock()
self.some_max_workers = mock.MagicMock()
self.some_delegate_treatment_log = mock.MagicMock()
self.thread_pool_executor_mock = self.patch(
'splitio.impressions.ThreadPoolExecutor')
self.treatment_log = AsyncTreatmentLog(
self.some_delegate_treatment_log,
max_workers=self.some_max_workers)
self.some_impression = Impression(
matching_key=self.some_key,
feature_name=self.some_feature_name,
treatment=self.some_treatment,
label=self.some_label,
change_number=self.some_change_number,
bucketing_key=self.some_key,
time=self.some_time)
