def test_set_scenario_resets_interaction_count(service: BaseService):
initial_interactions = {
'scenario_entered': {
'interaction_0': {
'num_calls': 3,
},
'interaction_1': {
'num_calls': 1,
}
},
'scenario_irrelevant': {
'interaction': 42,
},
}
expected = {
'scenario_entered': {},
'scenario_irrelevant': {
'interaction': 42,
},
}
service.interactions_replayed = initial_interactions
service.set_active_scenario('scenario_entered')
result = service.interactions_replayed
assert expected == result
def test_service_list_replace_from_decription():
expected = [
BaseService(name='ReplacedService',
hosts_list=['replaced_host.local']),
WhitelistService(name='WhitelistService',
hosts_list=['whitelist_me.local']),
]
service_list = ServiceList([
BaseService(name='OriginalService',
hosts_list=['original_host.local']),
])
service_list.replace_from_descrition([{
'type':
'BaseService',
'name':
'ReplacedService',
'hosts_list': ['replaced_host.local'],
}, {
'type': 'WhitelistService',
'name': 'WhitelistService',
'hosts_list': ['whitelist_me.local'],
}])
assert list(service_list) == expected
def service():
test_service = BaseService(
name='TestService',
hosts_list=['host_a.local', 'host_b.local'],
)
test_service.set_active_scenario('test_scenario')
return test_service
def test_increment_interaction_count_first(service: BaseService):
expected = 1
service.increment_interaction_count('test_interaction')
result = service.interactions_replayed[
service.active_scenario]['test_interaction']['num_calls']
assert expected == result
def dispatcher(scenarios_dir) -> Dispatcher:
return Dispatcher(service_list=[
BaseService(
name='TestServiceA',
hosts_list=['host_a.local'],
),
BaseService(
name='TestServiceB',
hosts_list=['host_b.local'],
),
], )
def test_process_request_fails_on_unknown_request(service: BaseService,
scenarios_dir):
request = MITMRequest(
body='{"value": "whatever"}',
headers=MITMHeaders({
'Accept': ['application/json'],
}),
method='PUT',
url='https://host_a.local/this/path/is/not/handled',
)
with raises(NoMatchingRecording):
service.process_request(request)
def test_increment_interaction_count_repeated(service: BaseService):
service.interactions_replayed[service.active_scenario] = {
'test_interaction': {
'num_calls': 5
},
}
expected = 6
service.increment_interaction_count('test_interaction')
result = service.interactions_replayed[
service.active_scenario]['test_interaction']['num_calls']
assert expected == result
def test_get_path_for_active_scenario_dir_from_envar_and_create(
tmpdir,
service: BaseService,
scenario_dir_exists: bool,
scenario_dir_envar: Optional[str],
expected_generated_path: str,
):
scenarios_dir = tmpdir.join('scenarios').mkdir()
if scenario_dir_exists:
scenarios_dir.join('test_scenario').mkdir()
scenarios_dir.join('test_scenario').join('TestService').mkdir()
assert scenarios_dir.join('test_scenario').join('TestService').exists()
else:
assert not scenarios_dir.join('test_scenario').join(
'TestService').exists()
with patch.dict(
environ,
{'SCENARIOS_PATH': scenario_dir_envar.format(tmpdir=tmpdir)}):
result_generated_path = service.get_path_for_active_scenario_dir(
create=True)
expected_generated_path = Path(
expected_generated_path.format(tmpdir=tmpdir))
assert result_generated_path == expected_generated_path
assert scenarios_dir.join('test_scenario').join('TestService').exists()
def dispatcher() -> Dispatcher:
return Dispatcher(service_list=[
BaseService(
name='TestService',
hosts_list=['test-service.local'],
),
], )
def test_service_list_prepend():
expected = [
BaseService(name='Service', hosts_list=['host.local']),
WhitelistService(name='WhitelistService',
hosts_list=['whitelist_me.local']),
]
service_list = ServiceList([
WhitelistService(name='WhitelistService',
hosts_list=['whitelist_me.local']),
])
service_list.prepend(BaseService(name='Service',
hosts_list=['host.local']))
assert list(service_list) == expected
def test_base_service_handles_request(service: BaseService, request_: dict,
handled: bool):
request_ = MITMRequest(
url=request_['url'],
headers=MITMHeaders(request_['headers']),
)
assert service.handles_request(request_) == handled
def test_should_replay_only_once(service: BaseService, scenarios_dir):
interaction = service.get_interactions_for_active_scenario()[0]
interaction.max_replays = 1
assert service.should_replay(interaction)
request_1 = MITMRequest(
headers=MITMHeaders({
'Accept': ['application/json'],
'Accept-Encoding': ['gzip, deflate'],
'Connection': ['keep-alive'],
'User-Agent': ['python-requests/2.18.4']
}),
method='GET',
url='https://host_a.local/api',
)
service.process_request(request_1)
assert not service.should_replay(interaction)
def management_service() -> ManagementService:
mgmt_service = ManagementService(
ServiceList([
BaseService(name='TestService', hosts_list=['test-service.local']),
]))
mgmt_service.config = {
'active_scenario': None,
'a_setting': 'value',
}
return mgmt_service
def test_get_path_for_active_scenario_dir_from_default_do_not_create_already_exists(
in_tmpdir,
service: BaseService,
):
scenarios_dir = in_tmpdir.join('scenarios').mkdir()
assert not scenarios_dir.join('test_scenario').join('TestService').exists()
result_generated_path = service.get_path_for_active_scenario_dir(
create=False)
expected_generated_path = Path(
'./scenarios/test_scenario/TestService/'.format(tmpdir=in_tmpdir))
assert result_generated_path == expected_generated_path
assert not scenarios_dir.join('test_scenario').join('TestService').exists()
def test_get_interactions_in_scenario(service: BaseService, request):
interaction_dir = request.fspath.join(
'../fixtures/scenarios/test_scenario/TestService/')
expected = [
f'Interaction.from_file({interaction_dir.join("interaction_0.yaml")})',
f'Interaction.from_file({interaction_dir.join("interaction_1.yaml")})',
]
with patch(
'inspire_mitmproxy.interaction.Interaction.from_file',
side_effect=lambda interaction_file:
f'Interaction.from_file({interaction_file})',
):
result = service.get_interactions_in_scenario(Path(interaction_dir))
assert expected == result
def test_base_service_get_interactions_for_active_scenario(
service: BaseService, scenarios_dir):
expected_request_1 = MITMRequest(
headers=MITMHeaders({
'Accept': ['application/json'],
'Accept-Encoding': ['gzip, deflate'],
'Connection': ['keep-alive'],
'User-Agent': ['python-requests/2.18.4']
}),
method='GET',
url='https://host_a.local/api',
)
expected_response_1 = MITMResponse(
body='{"value": "response1"}',
headers=MITMHeaders(
{'content-type': ['application/json; charset=UTF-8']}),
status_code=200,
)
expected_request_2 = MITMRequest(
body='{"value": "response2"}',
headers=MITMHeaders({
'Accept': ['application/json'],
'Accept-Encoding': ['gzip, deflate'],
'Connection': ['keep-alive'],
'User-Agent': ['python-requests/2.18.4']
}),
method='POST',
url='https://host_a.local/api',
)
expected_response_2 = MITMResponse(
headers=MITMHeaders(
{'content-type': ['application/json; charset=UTF-8']}),
status_code=201,
)
interactions = service.get_interactions_for_active_scenario()
assert len(interactions) == 2
assert interactions[0].request == expected_request_1
assert interactions[0].response == expected_response_1
assert interactions[1].request == expected_request_2
assert interactions[1].response == expected_response_2
def test_get_path_for_active_scenario_dir_from_envar_do_not_create(
tmpdir,
service: BaseService,
):
scenarios_dir = tmpdir.join('scenarios').mkdir()
assert not scenarios_dir.join('test_scenario').join('TestService').exists()
with patch.dict(
environ,
{'SCENARIOS_PATH': '{tmpdir}/scenarios/'.format(tmpdir=tmpdir)}):
result_generated_path = service.get_path_for_active_scenario_dir(
create=False)
expected_generated_path = Path(
'{tmpdir}/scenarios/test_scenario/TestService/'.format(
tmpdir=tmpdir))
assert result_generated_path == expected_generated_path
assert not scenarios_dir.join('test_scenario').join(
'TestService').exists()
def test_increment_interaction_count_repeated_on_multiple_scenarios(
service: BaseService):
service.interactions_replayed['scenario1'] = {
'test_interaction': {
'num_calls': 1
},
}
service.interactions_replayed['scenario2'] = {
'test_interaction': {
'num_calls': 10
},
}
expected_scenario1 = 2
expected_scenario2 = 10
service.active_scenario = 'scenario1'
service.increment_interaction_count('test_interaction')
result_scenario1 = service.interactions_replayed['scenario1'][
'test_interaction']['num_calls']
result_scenario2 = service.interactions_replayed['scenario2'][
'test_interaction']['num_calls']
assert expected_scenario1 == result_scenario1
assert expected_scenario2 == result_scenario2
expected_scenario1 = 2
expected_scenario2 = 11
service.active_scenario = 'scenario2'
service.increment_interaction_count('test_interaction')
result_scenario1 = service.interactions_replayed['scenario1'][
'test_interaction']['num_calls']
result_scenario2 = service.interactions_replayed['scenario2'][
'test_interaction']['num_calls']
assert expected_scenario1 == result_scenario1
assert expected_scenario2 == result_scenario2
def test_service_list_to_dict():
service_list = ServiceList([
BaseService(name='TestName',
hosts_list=['test_host.local', 'test_host2.local']),
WhitelistService(name='TestWhitelist', hosts_list=['test_host.local']),
])
expected_description = [
{
'type': 'BaseService',
'name': 'TestName',
'hosts_list': ['test_host.local', 'test_host2.local'],
},
{
'type': 'WhitelistService',
'name': 'TestWhitelist',
'hosts_list': ['test_host.local'],
},
]
result_service = service_list.to_list()
assert expected_description == result_service
def test_process_request(service: BaseService, request_: MITMRequest,
response: MITMResponse, scenarios_dir):
assert service.process_request(request_) == response
])
service_list.prepend(BaseService(name='Service',
hosts_list=['host.local']))
assert list(service_list) == expected
@mark.parametrize('service_description, expected_service', [
(
{
'type': 'BaseService',
'name': 'TestName',
'hosts_list': ['test_host.local', 'test_host2.local'],
},
BaseService(name='TestName',
hosts_list=['test_host.local', 'test_host2.local']),
),
(
{
'name': 'TestName',
'hosts_list': ['test_host.local'],
},
BaseService(name='TestName', hosts_list=['test_host.local']),
),
(
{
'type': 'WhitelistService',
'name': 'TestWhitelist',
'hosts_list': ['test_host.local'],
},
WhitelistService(name='TestWhitelist', hosts_list=['test_host.local']),
def test_should_not_replay(service: BaseService, scenarios_dir):
interaction = service.get_interactions_for_active_scenario()[0]
interaction.max_replays = 0
assert not service.should_replay(interaction)
def test_get_interactions_for_active_scenario_raises(service: BaseService,
scenarios_dir):
service.active_scenario = 'this_scenario_does_not_exist'
with raises(ScenarioNotInService):
service.get_interactions_for_active_scenario()
