Repository navigation
Expand file tree
/
Copy pathtest_config.py
More file actions
238 lines (197 loc) · 11.2 KB
/
Copy pathtest_config.py
File metadata and controls
238 lines (197 loc) · 11.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
"""Configuration unit tests."""
# pylint: disable=protected-access,no-self-use,line-too-long
import pytest
from splitio.client import config
from splitio.engine.impressions.impressions import ImpressionsMode
from splitio.models.fallback_treatment import FallbackTreatment
from splitio.models.fallback_config import FallbackTreatmentsConfiguration
class ConfigSanitizationTests(object):
"""Inmemory storage-based integration tests."""
def test_parse_operation_mode(self):
"""Make sure operation mode is correctly captured."""
assert (config._parse_operation_mode('some', {})) == ('standalone', 'memory')
assert (config._parse_operation_mode('localhost', {})) == ('localhost', 'localhost')
assert (config._parse_operation_mode('some', {'redisHost': 'x'})) == ('consumer', 'redis')
assert (config._parse_operation_mode('some', {'storageType': 'pluggable'})) == ('consumer', 'pluggable')
assert (config._parse_operation_mode('some', {'storageType': 'custom2'})) == ('standalone', 'memory')
def test_sanitize_imp_mode(self):
"""Test sanitization of impressions mode."""
mode, rate = config._sanitize_impressions_mode('memory', 'OPTIMIZED', 1)
assert mode == ImpressionsMode.OPTIMIZED
assert rate == 60
mode, rate = config._sanitize_impressions_mode('memory', 'DEBUG', 1)
assert mode == ImpressionsMode.DEBUG
assert rate == 1
mode, rate = config._sanitize_impressions_mode('redis', 'OPTIMIZED', 1)
assert mode == ImpressionsMode.OPTIMIZED
assert rate == 60
mode, rate = config._sanitize_impressions_mode('redis', 'debug', 1)
assert mode == ImpressionsMode.DEBUG
assert rate == 1
mode, rate = config._sanitize_impressions_mode('memory', 'ANYTHING', 200)
assert mode == ImpressionsMode.OPTIMIZED
assert rate == 200
mode, rate = config._sanitize_impressions_mode('pluggable', 'ANYTHING', 200)
assert mode == ImpressionsMode.OPTIMIZED
assert rate == 200
mode, rate = config._sanitize_impressions_mode('pluggable', 'NONE', 200)
assert mode == ImpressionsMode.NONE
assert rate == 200
mode, rate = config._sanitize_impressions_mode('pluggable', 'OPTIMIZED', 200)
assert mode == ImpressionsMode.OPTIMIZED
assert rate == 200
mode, rate = config._sanitize_impressions_mode('memory', 43, -1)
assert mode == ImpressionsMode.OPTIMIZED
assert rate == 60
mode, rate = config._sanitize_impressions_mode('memory', 'OPTIMIZED')
assert mode == ImpressionsMode.OPTIMIZED
assert rate == 300
mode, rate = config._sanitize_impressions_mode('memory', 'DEBUG')
assert mode == ImpressionsMode.DEBUG
assert rate == 60
def test_sanitize(self, mocker):
"""Test sanitization."""
_logger = mocker.Mock()
mocker.patch('splitio.client.config._LOGGER', new=_logger)
configs = {}
processed = config.sanitize('some', configs)
assert processed['redisLocalCacheEnabled'] # check default is True
assert processed['flagSetsFilter'] is None
assert processed['httpAuthenticateScheme'] is config.AuthenticateScheme.NONE
processed = config.sanitize('some', {'redisHost': 'x', 'flagSetsFilter': ['set']})
assert processed['flagSetsFilter'] is None
processed = config.sanitize('some', {'storageType': 'pluggable', 'flagSetsFilter': ['set']})
assert processed['flagSetsFilter'] is None
processed = config.sanitize('some', {'httpAuthenticateScheme': 'KERBEROS_spnego'})
assert processed['httpAuthenticateScheme'] is config.AuthenticateScheme.KERBEROS_SPNEGO
processed = config.sanitize('some', {'httpAuthenticateScheme': 'kerberos_proxy'})
assert processed['httpAuthenticateScheme'] is config.AuthenticateScheme.KERBEROS_PROXY
processed = config.sanitize('some', {'httpAuthenticateScheme': 'anything'})
assert processed['httpAuthenticateScheme'] is config.AuthenticateScheme.NONE
processed = config.sanitize('some', {'httpAuthenticateScheme': 'NONE'})
assert processed['httpAuthenticateScheme'] is config.AuthenticateScheme.NONE
_logger.reset_mock()
processed = config.sanitize('some', {'fallbackTreatments': 'NONE'})
assert processed['fallbackTreatments'] == None
assert _logger.warning.mock_calls[1] == mocker.call("Config: fallbackTreatments parameter should be of `FallbackTreatmentsConfiguration` class.")
_logger.reset_mock()
processed = config.sanitize('some', {'fallbackTreatments': FallbackTreatmentsConfiguration(123)})
assert processed['fallbackTreatments'].global_fallback_treatment == None
assert _logger.warning.mock_calls[1] == mocker.call("Config: global fallbacktreatment parameter is discarded.")
_logger.reset_mock()
processed = config.sanitize('some', {'fallbackTreatments': FallbackTreatmentsConfiguration(FallbackTreatment(123))})
assert processed['fallbackTreatments'].global_fallback_treatment == None
assert _logger.warning.mock_calls[1] == mocker.call("Config: global fallbacktreatment parameter is discarded.")
fb = FallbackTreatmentsConfiguration(FallbackTreatment('on'))
processed = config.sanitize('some', {'fallbackTreatments': fb})
assert processed['fallbackTreatments'].global_fallback_treatment.treatment == fb.global_fallback_treatment.treatment
assert processed['fallbackTreatments'].global_fallback_treatment.label == None
fb = FallbackTreatmentsConfiguration(FallbackTreatment('on'), {"flag": FallbackTreatment("off")})
processed = config.sanitize('some', {'fallbackTreatments': fb})
assert processed['fallbackTreatments'].global_fallback_treatment.treatment == fb.global_fallback_treatment.treatment
assert processed['fallbackTreatments'].by_flag_fallback_treatment["flag"] == fb.by_flag_fallback_treatment["flag"]
assert processed['fallbackTreatments'].by_flag_fallback_treatment["flag"].label == None
_logger.reset_mock()
fb = FallbackTreatmentsConfiguration(None, {"flag#%": FallbackTreatment("off"), "flag2": FallbackTreatment("on")})
processed = config.sanitize('some', {'fallbackTreatments': fb})
assert len(processed['fallbackTreatments'].by_flag_fallback_treatment) == 1
assert processed['fallbackTreatments'].by_flag_fallback_treatment.get("flag2") == fb.by_flag_fallback_treatment["flag2"]
assert _logger.warning.mock_calls[1] == mocker.call('Config: fallback treatment parameter for feature flag %s is discarded.', 'flag#%')
def test_sanitize_defaults_proxy_to_none(self):
"""Proxy fields default to None when not supplied."""
processed = config.sanitize('some', {})
assert processed['proxyHost'] is None
assert processed['proxyPort'] is None
assert processed['proxyProtocol'] is None
def test_sanitize_proxy_valid(self):
"""A fully valid proxy config is preserved as-is."""
processed = config.sanitize('some', {
'proxyHost': 'proxy.example.com',
'proxyPort': 8080,
'proxyProtocol': 'http',
})
assert processed['proxyHost'] == 'proxy.example.com'
assert processed['proxyPort'] == 8080
assert processed['proxyProtocol'] == 'http'
processed = config.sanitize('some', {
'proxyHost': 'proxy.example.com',
'proxyPort': 443,
'proxyProtocol': 'https',
})
assert processed['proxyHost'] == 'proxy.example.com'
assert processed['proxyPort'] == 443
assert processed['proxyProtocol'] == 'https'
def test_sanitize_proxy_host_only_disables_proxy(self, mocker):
"""If proxyHost is set but port/protocol are missing, proxyHost is cleared."""
_logger = mocker.Mock()
mocker.patch('splitio.client.config._LOGGER', new=_logger)
processed = config.sanitize('some', {'proxyHost': 'proxy.example.com'})
assert processed['proxyHost'] is None
assert processed['proxyPort'] is None
assert processed['proxyProtocol'] is None
_logger.warning.assert_any_call(
'To use proxy, parameters `proxyHost`, `proxyPort` and `proxyProtocol` must be set as str, int and str instances respectively.'
)
def test_sanitize_proxy_missing_protocol_disables_proxy(self, mocker):
"""Missing proxyProtocol invalidates the proxy config."""
_logger = mocker.Mock()
mocker.patch('splitio.client.config._LOGGER', new=_logger)
processed = config.sanitize('some', {
'proxyHost': 'proxy.example.com',
'proxyPort': 8080,
})
assert processed['proxyHost'] is None
_logger.warning.assert_any_call(
'To use proxy, parameters `proxyHost`, `proxyPort` and `proxyProtocol` must be set as str, int and str instances respectively.'
)
def test_sanitize_proxy_missing_port_disables_proxy(self, mocker):
"""Missing proxyPort invalidates the proxy config."""
_logger = mocker.Mock()
mocker.patch('splitio.client.config._LOGGER', new=_logger)
processed = config.sanitize('some', {
'proxyHost': 'proxy.example.com',
'proxyProtocol': 'https',
})
assert processed['proxyHost'] is None
_logger.warning.assert_any_call(
'To use proxy, parameters `proxyHost`, `proxyPort` and `proxyProtocol` must be set as str, int and str instances respectively.'
)
def test_sanitize_proxy_wrong_types_disables_proxy(self, mocker):
"""Wrong types for proxy fields invalidate the proxy config."""
_logger = mocker.Mock()
mocker.patch('splitio.client.config._LOGGER', new=_logger)
processed = config.sanitize('some', {
'proxyHost': 'proxy.example.com',
'proxyPort': '8080', # str, not int
'proxyProtocol': 'https',
})
assert processed['proxyHost'] is None
_logger.reset_mock()
processed = config.sanitize('some', {
'proxyHost': 'proxy.example.com',
'proxyPort': 8080,
'proxyProtocol': 123, # int, not str
})
assert processed['proxyHost'] is None
_logger.reset_mock()
processed = config.sanitize('some', {
'proxyHost': 12345, # int, not str
'proxyPort': 8080,
'proxyProtocol': 'https',
})
assert processed['proxyHost'] is None
def test_sanitize_proxy_invalid_protocol_defaults_to_https(self, mocker):
"""An unrecognized proxyProtocol falls back to 'https'."""
_logger = mocker.Mock()
mocker.patch('splitio.client.config._LOGGER', new=_logger)
processed = config.sanitize('some', {
'proxyHost': 'proxy.example.com',
'proxyPort': 8080,
'proxyProtocol': 'ftp',
})
assert processed['proxyHost'] == 'proxy.example.com'
assert processed['proxyPort'] == 8080
assert processed['proxyProtocol'] == 'https'
_logger.warning.assert_any_call(
'Parameter `proxyProtocol` should be either `http` or `https`, defaulting to `https`'
)