def test_replacing_placeholders(mocker, tmp_path):
"""
Given:
- Integration with placeholders, different servers
When:
- Calling _set_integration_params during creating integrations configurations
Then:
- Ensure that replacing placeholders happens not in place,
and next integration with same build_context, will able to replace '%%SERVER_HOST%%' placeholder.
"""
# Setting up the build context
filtered_tests = ['playbook_integration', 'playbook_second_integration']
# Setting up the content conf.json
tests = [
generate_test_configuration(
playbook_id='playbook_integration',
integrations=['integration_with_placeholders']),
generate_test_configuration(
playbook_id='playbook_second_integration',
integrations=['integration_with_placeholders'])
]
content_conf_json = generate_content_conf_json(
tests=tests,
unmockable_integrations={'FirstIntegration': 'reason'},
skipped_tests={})
# Setting up the content-test-conf conf.json
integration_names = ['integration_with_placeholders']
integrations_configurations = [
generate_integration_configuration(
name=integration_name, params={'url': '%%SERVER_HOST%%/server'})
for integration_name in integration_names
]
secret_test_conf = generate_secret_conf_json(integrations_configurations)
# Setting up the build_context instance
build_context = get_mocked_build_context(
mocker,
tmp_path,
content_conf_json=content_conf_json,
secret_conf_json=secret_test_conf,
filtered_tests_content=filtered_tests)
integration = Integration(build_context, 'integration_with_placeholders',
['instance'])
integration._set_integration_params(server_url='1.1.1.1',
playbook_id='playbook_integration',
is_mockable=False)
integration = Integration(build_context, 'integration_with_placeholders',
['instance'])
integration._set_integration_params(server_url='1.2.3.4',
playbook_id='playbook_integration',
is_mockable=False)
assert '%%SERVER_HOST%%' in build_context.secret_conf.integrations[
0].params.get('url')
def test_is_runnable_on_this_instance(mocker):
"""
Given:
- A test configuration configured to run only on instances that uses docker as container engine
When:
- The method _is_runnable_on_current_server_instance is invoked from the TestContext class
Then:
- Ensure that it returns False when the test is running on REHL instance that uses podman
- Ensure that it returns True when the test is running on a regular Linux instance that uses docker
"""
test_playbook_configuration = TestConfiguration(
generate_test_configuration(
playbook_id='playbook_runnable_only_on_docker',
runnable_on_docker_only=True),
default_test_timeout=30)
test_context_builder = partial(TestContext,
build_context=mocker.MagicMock(),
playbook=TestPlaybook(
mocker.MagicMock(),
test_playbook_configuration),
client=mocker.MagicMock())
test_context = test_context_builder(server_context=mocker.MagicMock(
is_instance_using_docker=False))
assert not test_context._is_runnable_on_current_server_instance()
test_context = test_context_builder(server_context=mocker.MagicMock(
is_instance_using_docker=True))
assert test_context._is_runnable_on_current_server_instance()
def init_server_context(mocker, tmp_path, mockable=False):
playbook_type = 'mocked_playbook' if mockable else 'unmocked_playbook'
playbook_id_type = 'mocked_playbook' if mockable else 'unmocked_playbook'
integrations_type = 'mocked_integration' if mockable else 'unmocked_integration'
mock_func = '_execute_unmockable_tests' if mockable else '_execute_mockable_tests'
unmockable_integration = {
integrations_type: 'reason'
} if not mockable else {}
filtered_tests = [playbook_type]
tests = [
generate_test_configuration(playbook_id=playbook_id_type,
integrations=[integrations_type])
]
integrations_configurations = [
generate_integration_configuration(integrations_type)
]
secret_test_conf = generate_secret_conf_json(integrations_configurations)
content_conf_json = generate_content_conf_json(
tests=tests, unmockable_integrations=unmockable_integration)
build_context = get_mocked_build_context(
mocker,
tmp_path,
secret_conf_json=secret_test_conf,
content_conf_json=content_conf_json,
filtered_tests_content=filtered_tests)
mocked_demisto_client = DemistoClientMock(integrations=[integrations_type])
server_context = generate_mocked_server_context(build_context,
mocked_demisto_client,
mocker)
mocker.patch.object(server_context, mock_func, return_value=None)
return build_context, server_context
def test_docker_thresholds_for_pwsh_integrations(mocker):
"""
Given:
- A test context with a playbook that uses a powershell integration
When:
- Running 'get_threshold_values' method
Then:
- Ensure that the memory threshold is the default powershell memory threshold value
- Ensure that the pis threshold is the default powershell pid threshold value
"""
test_playbook_configuration = TestConfiguration(
generate_test_configuration(
playbook_id='playbook_runnable_only_on_docker',
integrations=['integration']),
default_test_timeout=30)
playbook_instance = TestPlaybook(mocker.MagicMock(),
test_playbook_configuration)
playbook_instance.integrations[
0].integration_type = Docker.POWERSHELL_INTEGRATION_TYPE
test_context = TestContext(build_context=mocker.MagicMock(),
playbook=playbook_instance,
client=mocker.MagicMock(),
server_context=mocker.MagicMock())
memory_threshold, pid_threshold = test_context.get_threshold_values()
assert memory_threshold == Docker.DEFAULT_PWSH_CONTAINER_MEMORY_USAGE
assert pid_threshold == Docker.DEFAULT_PWSH_CONTAINER_PIDS_USAGE
def create_playbook_instance(mocker):
test_playbook_configuration = TestConfiguration(
generate_test_configuration(playbook_id='playbook_with_context',
integrations=['integration']),
default_test_timeout=30)
pb_instance = TestPlaybook(mocker.MagicMock(),
test_playbook_configuration)
pb_instance.build_context.logging_module = mocker.MagicMock()
return pb_instance
def test_second_playback_enforcement(mocker, tmp_path):
"""
Given:
- A mockable test
When:
- The mockable test fails on the second playback
Then:
- Ensure that it exists in the failed_playbooks set
- Ensure that it does not exists in the succeeded_playbooks list
"""
class RunIncidentTestMock:
call_count = 0
count_response_mapping = {
1: PB_Status.FAILED, # The first playback run
2: PB_Status.COMPLETED, # The record run
3: PB_Status.FAILED # The second playback run
}
@staticmethod
def run_incident_test(*_):
# First playback run
RunIncidentTestMock.call_count += 1
return RunIncidentTestMock.count_response_mapping[
RunIncidentTestMock.call_count]
filtered_tests = ['mocked_playbook']
tests = [
generate_test_configuration(playbook_id='mocked_playbook',
integrations=['mocked_integration'])
]
integrations_configurations = [
generate_integration_configuration('mocked_integration')
]
secret_test_conf = generate_secret_conf_json(integrations_configurations)
content_conf_json = generate_content_conf_json(tests=tests)
build_context = get_mocked_build_context(
mocker,
tmp_path,
secret_conf_json=secret_test_conf,
content_conf_json=content_conf_json,
filtered_tests_content=filtered_tests)
mocked_demisto_client = DemistoClientMock(
integrations=['mocked_integration'])
server_context = generate_mocked_server_context(build_context,
mocked_demisto_client,
mocker)
mocker.patch(
'demisto_sdk.commands.test_content.TestContentClasses.TestContext._run_incident_test',
RunIncidentTestMock.run_incident_test)
server_context.execute_tests()
assert 'mocked_playbook (Second Playback)' in build_context.tests_data_keeper.failed_playbooks
assert 'mocked_playbook' not in build_context.tests_data_keeper.succeeded_playbooks
def test_execute_tests(mocker, tmp_path):
"""
Given:
- A ServerContext instance that should execute three tests:
1) A test with no integrations
2) A test with mockable integration
3) A test with unmockable integration
When:
- Running execute_tests.
Then:
- Ensure the server context has executed all the tests
- Ensure the mockable and unmockable tests queues were emptied
- Ensure no test has failed during that test
"""
# Setting up the build context
filtered_tests = [
'playbook_without_integrations', 'playbook_with_mockable_integration',
'playbook_with_unmockable_integration', 'skipped_playbook'
]
# Setting up the content conf.json
tests = [
generate_test_configuration(
playbook_id='playbook_without_integrations'),
generate_test_configuration(
playbook_id='playbook_with_mockable_integration',
integrations=['mockable_integration']),
generate_test_configuration(
playbook_id='playbook_with_unmockable_integration',
integrations=['unmockable_integration']),
generate_test_configuration(playbook_id='skipped_playbook')
]
content_conf_json = generate_content_conf_json(
tests=tests,
unmockable_integrations={'unmockable_integration': 'reason'},
skipped_tests={'skipped_playbook': 'reason'})
# Setting up the content-test-conf conf.json
integration_names = ['mockable_integration', 'unmockable_integration']
integrations_configurations = [
generate_integration_configuration(integration_name)
for integration_name in integration_names
]
secret_test_conf = generate_secret_conf_json(integrations_configurations)
# Setting up the build_context instance
build_context = get_mocked_build_context(
mocker,
tmp_path,
content_conf_json=content_conf_json,
secret_conf_json=secret_test_conf,
filtered_tests_content=filtered_tests)
# Setting up the client
mocked_demisto_client = DemistoClientMock(integrations=integration_names)
server_context = generate_mocked_server_context(build_context,
mocked_demisto_client,
mocker)
server_context.execute_tests()
# Validating all tests were executed
for test in set(filtered_tests) - {'skipped_playbook'}:
assert test in server_context.executed_tests
# Validating all queues were emptied
assert build_context.mockable_tests_to_run.all_tasks_done
assert build_context.unmockable_tests_to_run.all_tasks_done
# Validating no failed playbooks
assert not build_context.tests_data_keeper.failed_playbooks
# Validating skipped test
assert 'skipped_playbook' not in server_context.executed_tests
assert 'skipped_playbook' in build_context.tests_data_keeper.skipped_tests