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())