Skip to content

Commit 0451cb1

Browse files
chillaqchillaq
committed
polish tests
1 parent 392fa24 commit 0451cb1

File tree

1 file changed

+68
-37
lines changed

1 file changed

+68
-37
lines changed

‎tests/client/test_client.py‎

Lines changed: 68 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@
2323
from splitio.engine.impressions.manager import Counter as ImpressionsCounter
2424
from splitio.engine.impressions.unique_keys_tracker import UniqueKeysTracker, UniqueKeysTrackerAsync
2525
from splitio.engine.telemetry import TelemetryStorageConsumer, TelemetryStorageProducer, TelemetryStorageProducerAsync
26-
from splitio.engine.evaluator import Evaluator
26+
from splitio.engine.evaluator import Evaluator, EvaluationContext
2727
from splitio.recorder.recorder import StandardRecorder, StandardRecorderAsync
2828
from splitio.engine.impressions.strategies import StrategyDebugMode, StrategyNoneMode, StrategyOptimizedMode
2929
from tests.integration import splits_json
@@ -1516,7 +1516,7 @@ def get_feature_flag_names_by_flag_sets(*_):
15161516
pass
15171517

15181518
@mock.patch('splitio.engine.evaluator.Evaluator.eval_with_context', side_effect=Exception())
1519-
def test_fallback_treatment_exception_no_impressions(self, mocker):
1519+
def test_fallback_treatment_exception(self, mocker):
15201520
# using fallback when the evaluator has RuntimeError exception
15211521
split_storage = mocker.Mock(spec=SplitStorage)
15221522
segment_storage = mocker.Mock(spec=SegmentStorage)
@@ -2890,6 +2890,9 @@ async def test_fallback_treatment_eval_exception(self, mocker):
28902890
impmanager = ImpressionManager(StrategyOptimizedMode(), StrategyNoneMode(), telemetry_producer.get_telemetry_runtime_producer())
28912891
recorder = StandardRecorderAsync(impmanager, event_storage, impression_storage, telemetry_evaluation_producer, telemetry_producer.get_telemetry_runtime_producer())
28922892

2893+
async def manager_start_task():
2894+
pass
2895+
28932896
factory = SplitFactoryAsync(mocker.Mock(),
28942897
{'splits': split_storage,
28952898
'segments': segment_storage,
@@ -2902,7 +2905,7 @@ async def test_fallback_treatment_eval_exception(self, mocker):
29022905
telemetry_producer,
29032906
telemetry_producer.get_telemetry_init_producer(),
29042907
mocker.Mock(),
2905-
mocker.Mock()
2908+
manager_start_task
29062909
)
29072910

29082911
self.imps = None
@@ -3020,7 +3023,7 @@ async def fetch_many_rbs(*_):
30203023

30213024
@pytest.mark.asyncio
30223025
@mock.patch('splitio.engine.evaluator.Evaluator.eval_with_context', side_effect=Exception())
3023-
def test_fallback_treatment_exception_no_impressions(self, mocker):
3026+
async def test_fallback_treatment_exception(self, mocker):
30243027
# using fallback when the evaluator has RuntimeError exception
30253028
split_storage = mocker.Mock(spec=SplitStorage)
30263029
segment_storage = mocker.Mock(spec=SegmentStorage)
@@ -3033,11 +3036,14 @@ def test_fallback_treatment_exception_no_impressions(self, mocker):
30333036
mocker.patch('splitio.client.client.utctime_ms', new=lambda: 1000)
30343037
mocker.patch('splitio.client.client.get_latency_bucket_index', new=lambda x: 5)
30353038

3036-
telemetry_storage = InMemoryTelemetryStorage()
3037-
telemetry_producer = TelemetryStorageProducer(telemetry_storage)
3039+
telemetry_storage = await InMemoryTelemetryStorageAsync.create()
3040+
telemetry_producer = TelemetryStorageProducerAsync(telemetry_storage)
30383041
impmanager = ImpressionManager(StrategyOptimizedMode(), StrategyNoneMode(), telemetry_producer.get_telemetry_runtime_producer())
3039-
recorder = StandardRecorder(impmanager, event_storage, impression_storage, telemetry_producer.get_telemetry_evaluation_producer(), telemetry_producer.get_telemetry_runtime_producer())
3040-
factory = SplitFactory(mocker.Mock(),
3042+
recorder = StandardRecorderAsync(impmanager, event_storage, impression_storage, telemetry_producer.get_telemetry_evaluation_producer(), telemetry_producer.get_telemetry_runtime_producer())
3043+
async def manager_start_task():
3044+
pass
3045+
3046+
factory = SplitFactoryAsync(mocker.Mock(),
30413047
{'splits': split_storage,
30423048
'segments': segment_storage,
30433049
'rule_based_segments': rb_segment_storage,
@@ -3046,52 +3052,64 @@ def test_fallback_treatment_exception_no_impressions(self, mocker):
30463052
mocker.Mock(),
30473053
recorder,
30483054
impmanager,
3049-
mocker.Mock(),
30503055
telemetry_producer,
30513056
telemetry_producer.get_telemetry_init_producer(),
3052-
mocker.Mock()
3057+
mocker.Mock(),
3058+
manager_start_task
30533059
)
30543060

30553061
self.imps = None
3056-
def put(impressions):
3062+
async def put(impressions):
30573063
self.imps = impressions
30583064
impression_storage.put = put
30593065

30603066
class TelemetrySubmitterMock():
30613067
def synchronize_config(*_):
30623068
pass
30633069
factory._telemetry_submitter = TelemetrySubmitterMock()
3064-
client = Client(factory, recorder, True, FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(FallbackTreatment("on-global"))))
3065-
treatment = client.get_treatment("key", "some")
3070+
client = ClientAsync(factory, recorder, True, FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(FallbackTreatment("on-global"))))
3071+
3072+
async def context_for(*_):
3073+
return EvaluationContext(
3074+
{},
3075+
{},
3076+
{}
3077+
)
3078+
client._context_factory.context_for = context_for
3079+
3080+
treatment = await client.get_treatment("key", "some")
30663081
assert(treatment == "on-global")
3067-
assert(self.imps == None)
3082+
assert(self.imps[0].treatment == "on-global")
3083+
assert(self.imps[0].label == "fallback - exception")
30683084

30693085
self.imps = None
30703086
client._fallback_treatment_calculator = FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(FallbackTreatment("on-global"), {'some': FallbackTreatment("on-local")}))
3071-
treatment = client.get_treatment("key2", "some")
3087+
treatment = await client.get_treatment("key2", "some")
30723088
assert(treatment == "on-local")
3073-
assert(self.imps == None)
3089+
assert(self.imps[0].treatment == "on-local")
3090+
assert(self.imps[0].label == "fallback - exception")
30743091

30753092
self.imps = None
30763093
client._fallback_treatment_calculator = FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(None, {'some': FallbackTreatment("on-local")}))
3077-
treatment = client.get_treatment("key3", "some")
3094+
treatment = await client.get_treatment("key3", "some")
30783095
assert(treatment == "on-local")
3079-
assert(self.imps == None)
3096+
assert(self.imps[0].treatment == "on-local")
3097+
assert(self.imps[0].label == "fallback - exception")
30803098

30813099
self.imps = None
30823100
client._fallback_treatment_calculator = FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(None, {'some2': FallbackTreatment("on-local")}))
3083-
treatment = client.get_treatment("key4", "some")
3101+
treatment = await client.get_treatment("key4", "some")
30843102
assert(treatment == "control")
3085-
assert(self.imps == None)
3103+
assert(self.imps[0].treatment == "control")
3104+
assert(self.imps[0].label == "exception")
30863105

30873106
try:
3088-
factory.destroy()
3107+
await factory.destroy()
30893108
except:
30903109
pass
30913110

30923111
@pytest.mark.asyncio
3093-
@mock.patch('splitio.client.client.Client.ready', side_effect=None)
3094-
def test_fallback_treatment_not_ready_impressions(self, mocker):
3112+
async def test_fallback_treatment_not_ready_impressions(self, mocker):
30953113
# using fallback when the evaluator has RuntimeError exception
30963114
split_storage = mocker.Mock(spec=SplitStorage)
30973115
segment_storage = mocker.Mock(spec=SegmentStorage)
@@ -3102,11 +3120,14 @@ def test_fallback_treatment_not_ready_impressions(self, mocker):
31023120
mocker.patch('splitio.client.client.utctime_ms', new=lambda: 1000)
31033121
mocker.patch('splitio.client.client.get_latency_bucket_index', new=lambda x: 5)
31043122

3105-
telemetry_storage = InMemoryTelemetryStorage()
3106-
telemetry_producer = TelemetryStorageProducer(telemetry_storage)
3123+
telemetry_storage = await InMemoryTelemetryStorageAsync.create()
3124+
telemetry_producer = TelemetryStorageProducerAsync(telemetry_storage)
31073125
impmanager = ImpressionManager(StrategyOptimizedMode(), StrategyNoneMode(), telemetry_producer.get_telemetry_runtime_producer())
3108-
recorder = StandardRecorder(impmanager, event_storage, impression_storage, telemetry_producer.get_telemetry_evaluation_producer(), telemetry_producer.get_telemetry_runtime_producer())
3109-
factory = SplitFactory(mocker.Mock(),
3126+
recorder = StandardRecorderAsync(impmanager, event_storage, impression_storage, telemetry_producer.get_telemetry_evaluation_producer(), telemetry_producer.get_telemetry_runtime_producer())
3127+
async def manager_start_task():
3128+
pass
3129+
3130+
factory = SplitFactoryAsync(mocker.Mock(),
31103131
{'splits': split_storage,
31113132
'segments': segment_storage,
31123133
'rule_based_segments': rb_segment_storage,
@@ -3115,50 +3136,60 @@ def test_fallback_treatment_not_ready_impressions(self, mocker):
31153136
mocker.Mock(),
31163137
recorder,
31173138
impmanager,
3118-
mocker.Mock(),
31193139
telemetry_producer,
31203140
telemetry_producer.get_telemetry_init_producer(),
3121-
mocker.Mock()
3141+
mocker.Mock(),
3142+
manager_start_task
31223143
)
31233144

31243145
self.imps = None
3125-
def put(impressions):
3146+
async def put(impressions):
31263147
self.imps = impressions
31273148
impression_storage.put = put
31283149

31293150
class TelemetrySubmitterMock():
31303151
def synchronize_config(*_):
31313152
pass
31323153
factory._telemetry_submitter = TelemetrySubmitterMock()
3133-
client = Client(factory, recorder, True, FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(FallbackTreatment("on-global"))))
3134-
client.ready = False
3154+
client = ClientAsync(factory, recorder, True, FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(FallbackTreatment("on-global"))))
3155+
ready_property = mocker.PropertyMock()
3156+
ready_property.return_value = False
3157+
type(factory).ready = ready_property
31353158

3136-
treatment = client.get_treatment("key", "some")
3159+
async def context_for(*_):
3160+
return EvaluationContext(
3161+
{"some": {}},
3162+
{},
3163+
{}
3164+
)
3165+
client._context_factory.context_for = context_for
3166+
3167+
treatment = await client.get_treatment("key", "some")
31373168
assert(self.imps[0].treatment == "on-global")
31383169
assert(self.imps[0].label == "fallback - not ready")
31393170

31403171
self.imps = None
31413172
client._fallback_treatment_calculator = FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(FallbackTreatment("on-global"), {'some': FallbackTreatment("on-local")}))
3142-
treatment = client.get_treatment("key2", "some")
3173+
treatment = await client.get_treatment("key2", "some")
31433174
assert(treatment == "on-local")
31443175
assert(self.imps[0].treatment == "on-local")
31453176
assert(self.imps[0].label == "fallback - not ready")
31463177

31473178
self.imps = None
31483179
client._fallback_treatment_calculator = FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(None, {'some': FallbackTreatment("on-local")}))
3149-
treatment = client.get_treatment("key3", "some")
3180+
treatment = await client.get_treatment("key3", "some")
31503181
assert(treatment == "on-local")
31513182
assert(self.imps[0].treatment == "on-local")
31523183
assert(self.imps[0].label == "fallback - not ready")
31533184

31543185
self.imps = None
31553186
client._fallback_treatment_calculator = FallbackTreatmentCalculator(FallbackTreatmentsConfiguration(None, {'some2': FallbackTreatment("on-local")}))
3156-
treatment = client.get_treatment("key4", "some")
3187+
treatment = await client.get_treatment("key4", "some")
31573188
assert(treatment == "control")
31583189
assert(self.imps[0].treatment == "control")
31593190
assert(self.imps[0].label == "not ready")
31603191

31613192
try:
3162-
factory.destroy()
3193+
await factory.destroy()
31633194
except:
31643195
pass

0 commit comments

Comments
 (0)