def test_that_errors_dont_stop_task(self, mocker): """Test that if fetching splits fails at some_point, the task will continue running.""" storage = mocker.Mock(spec=SplitStorage) api = mocker.Mock() def run(x): run._calls += 1 if run._calls == 1: return {'splits': [], 'since': -1, 'till': -1} if run._calls == 2: return {'splits': [], 'since': -1, 'till': -1} raise APIException("something broke") run._calls = 0 api.fetch_splits.side_effect = run storage.get_change_number.return_value = -1 split_synchronizer = SplitSynchronizer(api, storage) task = split_sync.SplitSynchronizationTask( split_synchronizer.synchronize_splits, 0.5) task.start() time.sleep(0.1) assert task.is_running() time.sleep(1) assert task.is_running() task.stop()
def test_synchronize_splits(self, mocker): split_storage = InMemorySplitStorage() split_api = mocker.Mock() split_api.fetch_splits.return_value = {'splits': self.splits, 'since': 123, 'till': 123} split_sync = SplitSynchronizer(split_api, split_storage) segment_storage = InMemorySegmentStorage() segment_api = mocker.Mock() segment_api.fetch_segment.return_value = {'name': 'segmentA', 'added': ['key1', 'key2', 'key3'], 'removed': [], 'since': 123, 'till': 123} segment_sync = SegmentSynchronizer(segment_api, split_storage, segment_storage) split_synchronizers = SplitSynchronizers(split_sync, segment_sync, mocker.Mock(), mocker.Mock(), mocker.Mock()) synchronizer = Synchronizer(split_synchronizers, mocker.Mock(spec=SplitTasks)) synchronizer.synchronize_splits(123) inserted_split = split_storage.get('some_name') assert isinstance(inserted_split, Split) assert inserted_split.name == 'some_name' if not segment_sync._worker_pool.wait_for_completion(): inserted_segment = segment_storage.get('segmentA') assert inserted_segment.name == 'segmentA' assert inserted_segment.keys == {'key1', 'key2', 'key3'}
def test_synchronize_splits_error(self, mocker): """Test that if fetching splits fails at some_point, the task will continue running.""" storage = mocker.Mock(spec=SplitStorage) api = mocker.Mock() def run(x): raise APIException("something broke") run._calls = 0 api.fetch_splits.side_effect = run storage.get_change_number.return_value = -1 split_synchronizer = SplitSynchronizer(api, storage) with pytest.raises(APIException): split_synchronizer.synchronize_splits(1)
def test_sync_all(self, mocker): split_storage = mocker.Mock(spec=SplitStorage) split_storage.get_change_number.return_value = 123 split_storage.get_segment_names.return_value = ['segmentA'] split_api = mocker.Mock() split_api.fetch_splits.return_value = {'splits': self.splits, 'since': 123, 'till': 123} split_sync = SplitSynchronizer(split_api, split_storage) segment_storage = mocker.Mock(spec=SegmentStorage) segment_storage.get_change_number.return_value = 123 segment_api = mocker.Mock() segment_api.fetch_segment.return_value = {'name': 'segmentA', 'added': ['key1', 'key2', 'key3'], 'removed': [], 'since': 123, 'till': 123} segment_sync = SegmentSynchronizer(segment_api, split_storage, segment_storage) split_synchronizers = SplitSynchronizers(split_sync, segment_sync, mocker.Mock(), mocker.Mock(), mocker.Mock()) synchronizer = Synchronizer(split_synchronizers, mocker.Mock(spec=SplitTasks)) synchronizer.sync_all() inserted_split = split_storage.put.mock_calls[0][1][0] assert isinstance(inserted_split, Split) assert inserted_split.name == 'some_name' inserted_segment = segment_storage.update.mock_calls[0][1] assert inserted_segment[0] == 'segmentA' assert inserted_segment[1] == ['key1', 'key2', 'key3'] assert inserted_segment[2] == []
def test_error(self, mocker): split_task = mocker.Mock(spec=SplitSynchronizationTask) split_tasks = SplitTasks(split_task, mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock()) storage = mocker.Mock(spec=SplitStorage) api = mocker.Mock() def run(x): raise APIException("something broke") api.fetch_splits.side_effect = run storage.get_change_number.return_value = -1 split_sync = SplitSynchronizer(api, storage) synchronizers = SplitSynchronizers(split_sync, mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock()) synchronizer = Synchronizer(synchronizers, split_tasks) manager = Manager(threading.Event(), synchronizer, mocker.Mock(), False) with pytest.raises(APIException): manager.start()
def test_not_called_on_till(self, mocker): """Test that sync is not called when till is less than previous changenumber""" storage = mocker.Mock(spec=SplitStorage) def change_number_mock(): return 2 storage.get_change_number.side_effect = change_number_mock def get_changes(*args, **kwargs): get_changes.called += 1 return None get_changes.called = 0 api = mocker.Mock() api.fetch_splits.side_effect = get_changes split_synchronizer = SplitSynchronizer(api, storage) split_synchronizer.synchronize_splits(1) assert get_changes.called == 0
def uwsgi_update_splits(user_config): """ Update splits task. :param user_config: User-provided configuration. :type user_config: dict """ config = _get_config(user_config) seconds = config['featuresRefreshRate'] split_sync = SplitSynchronizer( SplitsAPI( HttpClient(1500, config.get('sdk_url'), config.get('events_url')), config['apikey']), UWSGISplitStorage(get_uwsgi()), ) while True: try: split_sync.synchronize_splits() # pylint: disable=protected-access time.sleep(seconds) except Exception: # pylint: disable=broad-except _LOGGER.error('Error updating splits') _LOGGER.debug('Error: ', exc_info=True)
def test_sync_all_failed_splits(self, mocker): api = mocker.Mock() storage = mocker.Mock() def run(x, c): raise APIException("something broke") api.fetch_splits.side_effect = run split_sync = SplitSynchronizer(api, storage) split_synchronizers = SplitSynchronizers(split_sync, mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock()) sychronizer = Synchronizer(split_synchronizers, mocker.Mock(spec=SplitTasks)) sychronizer.synchronize_splits(None) # APIExceptions are handled locally and should not be propagated! sychronizer.sync_all() # sync_all should not throw!
def test_sync_all_failed_splits(self, mocker): api = mocker.Mock() storage = mocker.Mock() def run(x): raise APIException("something broke") api.fetch_splits.side_effect = run split_sync = SplitSynchronizer(api, storage) split_synchronizers = SplitSynchronizers(split_sync, mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock(), mocker.Mock()) sychronizer = Synchronizer(split_synchronizers, mocker.Mock(spec=SplitTasks)) with pytest.raises(APIException): sychronizer.synchronize_splits(None) with pytest.raises(APIException): sychronizer.sync_all()
def test_synchronize_splits_calling_segment_sync_once(self, mocker): split_storage = InMemorySplitStorage() split_api = mocker.Mock() split_api.fetch_splits.return_value = {'splits': self.splits, 'since': 123, 'till': 123} split_sync = SplitSynchronizer(split_api, split_storage) counts = {'segments': 0} def sync_segments(*_): """Sync Segments.""" counts['segments'] += 1 return True segment_sync = mocker.Mock() segment_sync.synchronize_segments.side_effect = sync_segments segment_sync.segment_exist_in_storage.return_value = False split_synchronizers = SplitSynchronizers(split_sync, segment_sync, mocker.Mock(), mocker.Mock(), mocker.Mock()) synchronizer = Synchronizer(split_synchronizers, mocker.Mock(spec=SplitTasks)) synchronizer.synchronize_splits(123, True) assert counts['segments'] == 1
def test_synchronize_splits(self, mocker): """Test split sync.""" storage = mocker.Mock(spec=SplitStorage) def change_number_mock(): change_number_mock._calls += 1 if change_number_mock._calls == 1: return -1 return 123 change_number_mock._calls = 0 storage.get_change_number.side_effect = change_number_mock storage.get_segment_names.return_value = [] api = mocker.Mock() splits = [{ 'changeNumber': 123, 'trafficTypeName': 'user', 'name': 'some_name', 'trafficAllocation': 100, 'trafficAllocationSeed': 123456, 'seed': 321654, 'status': 'ACTIVE', 'killed': False, 'defaultTreatment': 'off', 'algo': 2, 'conditions': [{ 'partitions': [{ 'treatment': 'on', 'size': 50 }, { 'treatment': 'off', 'size': 50 }], 'contitionType': 'WHITELIST', 'label': 'some_label', 'matcherGroup': { 'matchers': [{ 'matcherType': 'WHITELIST', 'whitelistMatcherData': { 'whitelist': ['k1', 'k2', 'k3'] }, 'negate': False, }], 'combiner': 'AND' } }] }] def get_changes(*args, **kwargs): get_changes.called += 1 if get_changes.called == 1: return {'splits': splits, 'since': -1, 'till': 123} else: return {'splits': [], 'since': 123, 'till': 123} get_changes.called = 0 api.fetch_splits.side_effect = get_changes from splitio.sync.split import SplitSynchronizer split_synchronizer = SplitSynchronizer(api, storage) split_synchronizer.synchronize_splits() assert mocker.call(-1, FetchOptions(True)) in api.fetch_splits.mock_calls assert mocker.call(123, FetchOptions(True)) in api.fetch_splits.mock_calls inserted_split = storage.put.mock_calls[0][1][0] assert isinstance(inserted_split, Split) assert inserted_split.name == 'some_name'
def test_synchronize_splits_cdn(self, mocker): """Test split sync with bypassing cdn.""" mocker.patch('splitio.sync.split._ON_DEMAND_FETCH_BACKOFF_MAX_RETRIES', new=3) from splitio.sync.split import SplitSynchronizer storage = mocker.Mock(spec=SplitStorage) def change_number_mock(): change_number_mock._calls += 1 if change_number_mock._calls == 1: return -1 elif change_number_mock._calls >= 2 and change_number_mock._calls <= 3: return 123 elif change_number_mock._calls <= 7: return 1234 return 12345 # Return proper cn for CDN Bypass change_number_mock._calls = 0 storage.get_change_number.side_effect = change_number_mock storage.get_segment_names.return_value = [] api = mocker.Mock() splits = [{ 'changeNumber': 123, 'trafficTypeName': 'user', 'name': 'some_name', 'trafficAllocation': 100, 'trafficAllocationSeed': 123456, 'seed': 321654, 'status': 'ACTIVE', 'killed': False, 'defaultTreatment': 'off', 'algo': 2, 'conditions': [{ 'partitions': [{ 'treatment': 'on', 'size': 50 }, { 'treatment': 'off', 'size': 50 }], 'contitionType': 'WHITELIST', 'label': 'some_label', 'matcherGroup': { 'matchers': [{ 'matcherType': 'WHITELIST', 'whitelistMatcherData': { 'whitelist': ['k1', 'k2', 'k3'] }, 'negate': False, }], 'combiner': 'AND' } }] }] def get_changes(*args, **kwargs): get_changes.called += 1 if get_changes.called == 1: return {'splits': splits, 'since': -1, 'till': 123} elif get_changes.called == 2: return {'splits': [], 'since': 123, 'till': 123} elif get_changes.called == 3: return {'splits': [], 'since': 123, 'till': 1234} elif get_changes.called >= 4 and get_changes.called <= 6: return {'splits': [], 'since': 1234, 'till': 1234} elif get_changes.called == 7: return {'splits': [], 'since': 1234, 'till': 12345} return {'splits': [], 'since': 12345, 'till': 12345} get_changes.called = 0 api.fetch_splits.side_effect = get_changes split_synchronizer = SplitSynchronizer(api, storage) split_synchronizer._backoff = Backoff(1, 1) split_synchronizer.synchronize_splits() assert mocker.call(-1, FetchOptions(True)) in api.fetch_splits.mock_calls assert mocker.call(123, FetchOptions(True)) in api.fetch_splits.mock_calls split_synchronizer._backoff = Backoff(1, 0.1) split_synchronizer.synchronize_splits(12345) assert mocker.call(12345, FetchOptions(True, 1234)) in api.fetch_splits.mock_calls assert len( api.fetch_splits.mock_calls ) == 8 # 2 ok + BACKOFF(2 since==till + 2 re-attempts) + CDN(2 since==till) inserted_split = storage.put.mock_calls[0][1][0] assert isinstance(inserted_split, Split) assert inserted_split.name == 'some_name'
def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None, # pylint:disable=too-many-arguments,too-many-locals auth_api_base_url=None, streaming_api_base_url=None): """Build and return a split factory tailored to the supplied config.""" if not input_validator.validate_factory_instantiation(api_key): return None http_client = HttpClient( sdk_url=sdk_url, events_url=events_url, auth_url=auth_api_base_url, timeout=cfg.get('connectionTimeout') ) sdk_metadata = util.get_metadata(cfg) apis = { 'auth': AuthAPI(http_client, api_key, sdk_metadata), 'splits': SplitsAPI(http_client, api_key), 'segments': SegmentsAPI(http_client, api_key), 'impressions': ImpressionsAPI(http_client, api_key, sdk_metadata, cfg['impressionsMode']), 'events': EventsAPI(http_client, api_key, sdk_metadata), 'telemetry': TelemetryAPI(http_client, api_key, sdk_metadata) } if not input_validator.validate_apikey_type(apis['segments']): return None storages = { 'splits': InMemorySplitStorage(), 'segments': InMemorySegmentStorage(), 'impressions': InMemoryImpressionStorage(cfg['impressionsQueueSize']), 'events': InMemoryEventStorage(cfg['eventsQueueSize']), 'telemetry': InMemoryTelemetryStorage() } imp_manager = ImpressionsManager( storages['impressions'].put, cfg['impressionsMode'], True, _wrap_impression_listener(cfg['impressionListener'], sdk_metadata)) synchronizers = SplitSynchronizers( SplitSynchronizer(apis['splits'], storages['splits']), SegmentSynchronizer(apis['segments'], storages['splits'], storages['segments']), ImpressionSynchronizer(apis['impressions'], storages['impressions'], cfg['impressionsBulkSize']), EventSynchronizer(apis['events'], storages['events'], cfg['eventsBulkSize']), TelemetrySynchronizer(apis['telemetry'], storages['telemetry']), ImpressionsCountSynchronizer(apis['impressions'], imp_manager), ) tasks = SplitTasks( SplitSynchronizationTask( synchronizers.split_sync.synchronize_splits, cfg['featuresRefreshRate'], ), SegmentSynchronizationTask( synchronizers.segment_sync.synchronize_segments, cfg['segmentsRefreshRate'], ), ImpressionsSyncTask( synchronizers.impressions_sync.synchronize_impressions, cfg['impressionsRefreshRate'], ), EventsSyncTask(synchronizers.events_sync.synchronize_events, cfg['eventsPushRate']), TelemetrySynchronizationTask( synchronizers.telemetry_sync.synchronize_telemetry, cfg['metricsRefreshRate'], ), ImpressionsCountSyncTask(synchronizers.impressions_count_sync.synchronize_counters) ) synchronizer = Synchronizer(synchronizers, tasks) sdk_ready_flag = threading.Event() manager = Manager(sdk_ready_flag, synchronizer, apis['auth'], cfg['streamingEnabled'], streaming_api_base_url) initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer") initialization_thread.setDaemon(True) initialization_thread.start() storages['events'].set_queue_full_hook(tasks.events_task.flush) storages['impressions'].set_queue_full_hook(tasks.impressions_task.flush) return SplitFactory(api_key, storages, cfg['labelsEnabled'], imp_manager, manager, sdk_ready_flag)
def test_normal_operation(self, mocker): """Test the normal operation flow.""" storage = mocker.Mock(spec=SplitStorage) def change_number_mock(): change_number_mock._calls += 1 if change_number_mock._calls == 1: return -1 return 123 change_number_mock._calls = 0 storage.get_change_number.side_effect = change_number_mock api = mocker.Mock() splits = [{ 'changeNumber': 123, 'trafficTypeName': 'user', 'name': 'some_name', 'trafficAllocation': 100, 'trafficAllocationSeed': 123456, 'seed': 321654, 'status': 'ACTIVE', 'killed': False, 'defaultTreatment': 'off', 'algo': 2, 'conditions': [{ 'partitions': [{ 'treatment': 'on', 'size': 50 }, { 'treatment': 'off', 'size': 50 }], 'contitionType': 'WHITELIST', 'label': 'some_label', 'matcherGroup': { 'matchers': [{ 'matcherType': 'WHITELIST', 'whitelistMatcherData': { 'whitelist': ['k1', 'k2', 'k3'] }, 'negate': False, }], 'combiner': 'AND' } }] }] def get_changes(*args, **kwargs): get_changes.called += 1 if get_changes.called == 1: return {'splits': splits, 'since': -1, 'till': 123} else: return {'splits': [], 'since': 123, 'till': 123} get_changes.called = 0 api.fetch_splits.side_effect = get_changes split_synchronizer = SplitSynchronizer(api, storage) task = split_sync.SplitSynchronizationTask( split_synchronizer.synchronize_splits, 0.5) task.start() time.sleep(0.7) assert task.is_running() stop_event = threading.Event() task.stop(stop_event) stop_event.wait() assert not task.is_running() assert mocker.call(-1) in api.fetch_splits.mock_calls assert mocker.call(123) in api.fetch_splits.mock_calls inserted_split = storage.put.mock_calls[0][1][0] assert isinstance(inserted_split, Split) assert inserted_split.name == 'some_name'