def create_harness(success_patterns=None, failure_patterns=None):
entity = 'binaryid'
config = ConfigManager()
config.set(CONSOLE_binaryid, [entity])
config.set(CONSOLE_BINARY_PATH, 'binary_path', entity=entity)
config.set(CONSOLE_BINARY_TIMEOUT, 3, entity=entity)
if success_patterns is not None:
config.set(CONSOLE_BINARY_PASSED_PATTERN,
success_patterns,
entity=entity)
if failure_patterns is not None:
config.set(CONSOLE_BINARY_FAILED_PATTERN,
failure_patterns,
entity=entity)
return ExtensionTestHarness(
ConsoleRunner,
endpoints_and_messages={
MULTI_RUNNER_ENDPOINT: [
TEST_RUN_STARTED, TEST_RUN_FINISHED, TEST_CASE_STARTED,
TEST_CASE_FINISHED
]
},
config=config,
)
def _create_harness(config=None):
config_manager = ConfigManager()
for id, value in config.items() if config else []:
config_manager.set(id, value)
return ExtensionTestHarness(Metrics,
config=config_manager,
endpoints_and_messages={})
def create_harness(endpoints_and_messages, config):
config_manager = ConfigManager()
for id, value in config.items():
config_manager.set(id, value)
return ExtensionTestHarness(
RemoteServer, endpoints_and_messages=endpoints_and_messages, config=config_manager)
def test_multiple_suts_only_adds_enabled_serial_ports(self):
suts = ['sut1', 'sut2', 'sut3']
devices = ['/dev/device1', '/dev/device3']
config = ConfigManager()
config.set(SUT, suts)
config.set(SUT_SERIAL_ENABLED, True, entity=suts[0])
config.set(SUT_SERIAL_ENABLED, False, entity=suts[1])
config.set(SUT_SERIAL_ENABLED, True, entity=suts[2])
config.set(SUT_SERIAL_DEVICE, devices[0], entity=suts[0])
config.set(SUT_SERIAL_DEVICE, devices[1], entity=suts[2])
with ExtensionTestHarness(SerialFrameworkExtension,
config=config) as harness:
ext_config = harness.extension.get_config(config, Mock(), Mock())
self.assertNotEqual(len(ext_config.config), 0)
self.assertEqual(ext_config.config[SERIAL_PORT_IDS.key],
['sut1', 'sut3'])
self.assertEqual(
ext_config.config[config_key(SERIAL_ENABLED, suts[0])], True)
self.assertEqual(
ext_config.config[config_key(SERIAL_ENABLED, suts[2])], True)
self.assertEqual(
ext_config.config[config_key(SERIAL_DEVICE, suts[0])],
devices[0])
self.assertEqual(
ext_config.config[config_key(SERIAL_DEVICE, suts[2])],
devices[1])
with self.assertRaises(KeyError):
ext_config.config[config_key(SERIAL_ENABLED, suts[1])]
def _create_harness():
config = ConfigManager()
entity = 'mysut'
config.set(SUT, [entity])
config.set(SUT_PROC_MEMORY_USAGE_MONITOR_IDS,
['mymonitor', 'myothermonitor'],
entity=entity)
config.set(PROC_MEMORY_USAGE_MONITOR_IDS, ['mymonitor', 'myothermonitor'])
config.set(PROC_MEMORY_USAGE_MONITOR_PATTERNS, ['my_pattern'],
entity='mymonitor')
config.set(PROC_MEMORY_USAGE_MONITOR_PATTERNS, ['my_other_pattern'],
entity='myothermonitor')
exec = Mock()
proc_pid_collector = Mock()
create_series_metric = Mock()
harness = ExtensionTestHarness(ProcMemoryUsageMonitor,
config=config,
endpoints_and_messages={
MONITOR_ENDPOINT: [PERFORM_MEASUREMENT],
MOCK_ENDPOINT: [SUT_RESET_DONE]
},
components=[
ComponentMock(name='Exec',
mock=exec,
can=['telnet']),
ComponentMock(name='ProcPidCollector',
mock=proc_pid_collector),
ComponentMock(name='CreateSeriesMetric',
mock=create_series_metric)
])
harness.exec = exec
harness.proc_pid_collector = proc_pid_collector
harness.create_series_metric = create_series_metric
return harness
def _get_config(options={}):
defaults = {
IMAGE_OPTION: 'abs.u14',
IMAGE_OVERRIDE_OPTION: None,
TAG_OPTION: 'TAG',
REGISTRY_OPTION: 'REGISTRY',
USE_REGISTRY_OPTION: True,
PULL_OPTION: False,
ENV_VARIABLES_OPTION: [],
MOUNTS_OPTION: [],
HOSTNAME_OPTION: 'HOSTNAME',
ROOT_OPTION: False,
ROOT_DIR_OPTION: None,
CONTAINER_ROOT_DIR_OPTION: '/zebra/workspace',
PROJECT_DIR_OPTION: None,
PROJECT_DIR_NAME_OPTION: None,
NETWORK_OPTION: None,
}
for key, value in options.items():
defaults[key] = value
config = ConfigManager()
for key, value in defaults.items():
config.set(key, value)
return DockerConfig(config)
def create_harness(csv_enabled=True,
csv_path='path/to/csv/report.csv',
json_enabled=True,
json_path='path/to/json/report.json',
text_enabled=True,
text_path='path/to/text/report.text'):
metric_mock = Mock()
config = ConfigManager()
config.set(PROFILING_DIR, 'profiling')
config.set(PROFILING_CSV, csv_enabled)
config.set(PROFILING_CSV_PATH, csv_path)
config.set(PROFILING_JSON, json_enabled)
config.set(PROFILING_JSON_PATH, json_path)
config.set(PROFILING_TEXT, text_enabled)
config.set(PROFILING_TEXT_PATH, text_path)
harness = ExtensionTestHarness(
Profiling,
endpoints_and_messages={
APPLICATION_ENDPOINT: [BEFORE_COMMAND, AFTER_COMMAND]
},
config=config,
components=[
ComponentMock(name='CreateSingleValueMetric', mock=metric_mock)
])
harness.metrics_mock = metric_mock
return harness
def test_get_config_does_not_create_config_when_not_enabled(self):
config = ConfigManager()
config.set_default_values([ANSIBLE_NODES, ANSIBLE_NODE])
config.set(ANSIBLE_NODES, ['1', '2', '3'])
config.set(ANSIBLE_ENABLED, False)
ansible_suts = AnsibleSuts(None, None)
self.assertNotIn('suts.ids',
ansible_suts.get_config(config, [], {}).config)
def _create_harness(enabled=True):
config = ConfigManager()
config.set(ABORT_ON_FAIL_ENABLED, enabled)
harness = ExtensionTestHarness(
AbortOnFail,
config=config,
endpoints_and_messages={RUNNER_ENDPOINT: [TEST_CASE_FINISHED]})
return harness
def _create_harness():
config = ConfigManager()
with patch('os.path.exists', return_value=True):
config.set(PLUGIN_DIRS, ['/path/to/plugins'])
return ExtensionTestHarness(
AsciidoctorPlugins,
config=config,
)
def create_harness(verbosity=0):
config = ConfigManager()
if verbosity > 0:
config.set(VERBOSE, verbosity)
return ExtensionTestHarness(
ZebraLoggingExtension,
config=config,
)
def create_harness(docker_run=Mock()):
config = ConfigManager()
config.set(EXEC_COMMAND_WITH_ARGUMENTS, ('exec', 'with', 'args'))
return ExtensionTestHarness(
CacheExtension,
config=config,
components=[ComponentMock('DockerRun', docker_run)],
)
def _create_harness(env=Mock()):
config = ConfigManager()
with patch('os.path.exists', return_value=True):
config.set(ADOC_FILE, 'file.adoc')
return ExtensionTestHarness(
AsciidoctorExtension,
endpoints_and_messages={OPTIONS_ENDPOINT: [GET_ASCIIDOCTOR_OPTIONS]},
config=config,
components=[ComponentMock('Env', env)])
def test_no_ports(self):
sut = 'sut'
config = ConfigManager()
config.set(SUT, [sut])
config.set(SUT_SERIAL_PORTS, [], entity=sut)
with ExtensionTestHarness(SerialFrameworkExtension,
config=config) as harness:
ext_config = harness.extension.get_config(config, Mock(), Mock())
self.assertEqual(ext_config.config, {})
def create_harness():
config = ConfigManager()
config.set(MULTI_RUNNER_ENABLED, True)
return ExtensionTestHarness(MultiRunner,
config=config,
endpoints_and_messages={
RUN_COMMAND_ENDPOINT: [TEST_RUN],
})
def test_enabling_remote_client_registers_component(self):
component_manager = ComponentManager()
component_manager.clear_component_registry()
config = ConfigManager()
config.set(REMOTE_CLIENT_ENABLED, True)
with ExtensionTestHarness(RemoteClientExtension, config=config):
self.assertIn('RemoteClient', component_manager.COMPONENT_REGISTRY)
def test_disabled_does_not_register_to_messages(self):
config = ConfigManager()
config.set(REPORTS_TESTNG, False)
with ExtensionTestHarness(TestNgReporter, config=config) as h:
assert not h.any_registered_dispatchers(TEST_RESULTS_COLLECTED,
RESULTS_ENDPOINT)
assert not h.any_registered_dispatchers(POST_TEST_RUN,
RUN_COMMAND_ENDPOINT)
def create_harness():
config = ConfigManager()
config.set(SUT, ['mysut'])
return ExtensionTestHarness(
HealthMonitor,
config=config,
endpoints_and_messages={
MOCK_ENDPOINT: [TEST_CASE_FINISHED, SUT_RECOVERY_PERFORM],
})
def _create_harness(timeout='10'):
config = ConfigManager()
config.set(COMMAND_TIMEOUT, timeout)
return ExtensionTestHarness(CommandTimeout,
config=config,
endpoints_and_messages={
RUN_COMMAND_ENDPOINT:
[BEFORE_COMMAND, AFTER_COMMAND]
})
def create_harness(docker_run=Mock(), image='abs.u16'):
config = ConfigManager()
config.set(MAKE_ARGUMENTS, ('arg1', '--opt2'))
config.set(IMAGE_OPTION, image)
return ExtensionTestHarness(
MakeExtension,
config=config,
components=[ComponentMock('DockerRun', docker_run)],
)
def test_get_config_uses_ansible_nodes_as_suts_when_ansible_node_is_not_set(
self):
config = ConfigManager()
config.set_default_values([ANSIBLE_NODES, ANSIBLE_NODE])
config.set(ANSIBLE_NODES, ['1', '2', '3'])
config.set(ANSIBLE_ENABLED, True)
ansible_suts = AnsibleSuts(None, None)
self.assertCountEqual(
ansible_suts.get_config(config, [], {}).config['suts.ids'],
['1', '2', '3'])
def setUp(self):
output_dir = './output'
config = ConfigManager()
config.set(OUTPUT_DIR, output_dir)
component_context = Mock()
component_context.callable_qualname = 'package.module.test_case'
self.workspace = Workspace(component_context, config)
def create_powermeter_harness(sut=['entity'], gude_port=0, gude_ip='ip', power_meter='gude'):
config = ConfigManager()
entity = sut[0]
config.set(SUT, sut)
config.set(AVAILABLE_POWER_METERS, ['gude', 'notgude'])
config.set(POWER_METER, power_meter, entity=entity)
config.set(GUDE_PORT, gude_port, entity=entity)
config.set(GUDE_IP, gude_ip, entity=entity)
return ExtensionTestHarness(GudePowerMeterExtension, config=config)
def create_powerswitch_harness(sut=['entity'], gude_port=0, gude_ip='ip', power_switch='gude'):
config = ConfigManager()
entity = sut[0]
config.set(SUT, sut)
config.set(AVAILABLE_POWER_SWITCHES, ['gude', 'notgude'])
config.set(POWER_SWITCH, power_switch, entity=entity)
config.set(GUDE_PORT, gude_port, entity=entity)
config.set(GUDE_IP, gude_ip, entity=entity)
return ExtensionTestHarness(GudePowerSwitchExtension, config=config)
def test_clean_containers_does_not_do_anything_when_suts_does_not_can_docker(self):
manager = Mock()
manager.get_cans.return_value = []
config = ConfigManager()
config.set(SUT, ['sut1', 'sut2'])
docker = Mock()
with patch('virt.docker_clean.get_docker_client', return_value=docker), \
patch('virt.docker_clean.get_container') as m:
clean_containers(Mock(), manager, config)
m.assert_not_called()
def _create_harness(enabled=True):
config = ConfigManager()
config.set(ABORT_ON_UNEXPECTED_SUT_RESET, enabled)
harness = ExtensionTestHarness(
AbortOnUnexpectedSutReset,
config=config,
endpoints_and_messages={
RUNNER_ENDPOINT: [SUT_RESET_STARTED]
})
return harness
def create_harness():
config = ConfigManager()
config.set(Z2_REPORTS, True)
config.set(Z2_REPORTS_FILE, 'z2-report.json')
harness = ExtensionTestHarness(
FileReporter,
config=config,
endpoints_and_messages={
Z2_REPORTS_ENDPOINT: [Z2_INTERNAL_PUBLISH_REPORT_REQUEST],
})
return harness
def create_harness():
config = ConfigManager()
config.set(Z2_REPORTS, True)
config.set(Z2_REPORTS_URL, 'http://z2.myawesomedomain.lan')
harness = ExtensionTestHarness(
UploadReporter,
config=config,
endpoints_and_messages={
Z2_REPORTS_ENDPOINT: [Z2_INTERNAL_PUBLISH_REPORT_REQUEST],
})
return harness
def create_harness(duration=None, repeats=None):
config = ConfigManager()
config.set(LOOP_DURATION, duration)
config.set(LOOP_REPEATS, repeats)
return ExtensionTestHarness(Looper,
config=config,
endpoints_and_messages={
SCHEDULER_ENDPOINT: [
RUN_QUEUE_EMPTY, RUN_QUEUE_INITIALIZED,
ADD_TEST_CASES, TEST_RUN_STARTED
]
})
def test_mix_sut_and_port_id_options_raises_exception(self):
sut = 'sut'
port = 'port'
config = ConfigManager()
config.set(SUT, [sut])
config.set(SUT_SERIAL_ENABLED, True, entity=sut)
config.set(SUT_SERIAL_DEVICE, '/dev/null', entity=sut)
config.set(SUT_SERIAL_PORTS, [port], entity=sut)
config.set(SERIAL_ENABLED, True, entity=port)
with ExtensionTestHarness(SerialFrameworkExtension, config=config) as harness, \
self.assertRaises(MissingConditionalConfigOption):
harness.extension.get_config(config, Mock(), Mock())
