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(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 _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(verbosity=0): config = ConfigManager() if verbosity > 0: config.set(VERBOSE, verbosity) return ExtensionTestHarness( ZebraLoggingExtension, config=config, )
def setUp(self): self.plugin = ClickParseCli({}, {}) self.config = ConfigManager() self.options = [OPTION_INTERNAL, OPTION_EXTENDABLE, OPTION_NONE] self.commands_with_options = { COMMAND_INTERNAL: [OPTION_INTERNAL, OPTION_EXTENDABLE, OPTION_NONE], COMMAND_EXTENDABLE: [OPTION_INTERNAL, OPTION_EXTENDABLE, OPTION_NONE], COMMAND_NONE: [OPTION_INTERNAL, OPTION_EXTENDABLE, OPTION_NONE], }
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 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 _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(sut=['entity'], power_meter='dummy', value=4.2): config = ConfigManager() entity = sut[0] config.set(SUT, sut) config.set(AVAILABLE_POWER_METERS, ['dummy', 'notgude']) config.set(POWER_METER, power_meter, entity=entity) config.set(DUMMY_POWER_METER_VALUE, value, entity=entity) return ExtensionTestHarness(DummyPowerMeter, config=config)
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 create_harness(): config = ConfigManager() config.set(MULTI_RUNNER_ENABLED, True) return ExtensionTestHarness(MultiRunner, config=config, endpoints_and_messages={ RUN_COMMAND_ENDPOINT: [TEST_RUN], })
def create_config(options, entity=None, additional_options={}): config = ConfigManager() for option_id, value in options.items(): key = config._option_key(option_id, entity) config._config[key].add(value, 1, '') for option, value in additional_options.items(): key = config._option_key(option.option_id) config._config[key].add(value, 1, '') return config
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(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 test_get_config_uses_ansible_node_as_suts_when_set(self): config = ConfigManager() config.set_default_values([ANSIBLE_NODES, ANSIBLE_NODE]) config.set(ANSIBLE_NODES, ['1', '2', '3']) config.set(ANSIBLE_NODE, ['2', '3']) config.set(ANSIBLE_ENABLED, True) ansible_suts = AnsibleSuts(None, None) self.assertCountEqual( ansible_suts.get_config(config, [], {}).config['suts.ids'], ['2', '3'])
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(): config = ConfigManager() config.set(SUT, ['mysut']) return ExtensionTestHarness( HealthMonitor, config=config, endpoints_and_messages={ MOCK_ENDPOINT: [TEST_CASE_FINISHED, SUT_RECOVERY_PERFORM], })
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_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 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 test_serial_log_not_enabled(self): sut = 'sut' port = 'port' config = ConfigManager() config.set(SUT, [sut]) config.set(SUT_SERIAL_PORTS, [port], entity=sut) config.set(SERIAL_ENABLED, True, entity=port) config.set(SERIAL_LOG_ENABLED, False, entity=port) 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() entity = 'myjsonreporter' config.set(JSON_REPORTER_ID, [entity]) config.set(JSON_DIRECTORY, 'my/json/directory', entity=entity) config.set(JSON_FILENAME, 'myreport.json', entity=entity) config.set(JSON_NAMESPACE, 'my_metrics_namespace', entity=entity) return ExtensionTestHarness( MetricsJsonReporter, config=config, endpoints_and_messages={METRICS_ENDPOINT: [GENERATE_METRICS_REPORT]}, )
def create_harness(headless=True, firefox_enabled=False): config = ConfigManager() config.set(ZELENIUM_ENABLED, True) config.set(ZELENIUM_HEADLESS, headless) config.set(ZELENIUM_FIREFOX, firefox_enabled) return ExtensionTestHarness(Zelenium, config=config)
def test_sets_root_logger_level_and_attaches_stdout_handler(self): logger = MagicMock() handler = Mock() config = ConfigManager() config.set(LOG_LEVEL, 'warning') with patch('logging.getLogger', return_value=logger), \ patch('logging.StreamHandler', return_value=handler), \ patch('zaf.builtin.logging.logging.Filter', return_value=filter) as get_filter: with ExtensionTestHarness(RootLogger, config=config): logger.setLevel.assert_called_with(logging.DEBUG) logger.addHandler.assert_called_with(handler) self.assertEqual(handler.addFilter.call_count, 1) get_filter.assert_called_with({'': 30})
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 test_sut_serial_log_enabled_adds_log_source(self): sut = 'sut' 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_LOG_ENABLED, True, entity=sut) with ExtensionTestHarness(SerialFrameworkExtension, config=config) as harness: ext_config = harness.extension.get_config(config, Mock(), Mock()) self.assertGreater(len(ext_config.config), 0) self.assertEqual(ext_config.config[SERIAL_PORT_IDS.key], [sut]) self.assertEqual( ext_config.config[config_key(SUT_LOG_SOURCES, sut)], ['serial-sut'])
def create_harness( znail_cc_enabled=True, znail_cc_required=True, sut=['entity'], component_mock=None): config = ConfigManager() entity = sut[0] config.set(SUT, sut) config.set(ZNAIL_IP, '1.2.3.4', entity=entity) config.set(ZNAIL_CONNECTION_CHECK_ENABLED, znail_cc_enabled, entity=entity) config.set(ZNAIL_CONNECTION_CHECK_REQUIRED, znail_cc_required, entity=entity) if component_mock is None: component_mock = Mock() return ExtensionTestHarness( ZnailConnectionCheck, config=config, components=[ComponentMock(name='Znail', mock=component_mock)])
def test_throws_on_unexpected_exit_code(self): with _create_harness(ConfigManager()) as harness: scope = Scope(name='myscope') exec = harness.component_factory.call(DockerContainerExec, scope) harness.node._container.exec.return_value = ('stdout', 'stderr', 1) with self.assertRaises(DockerError): exec.send_line('command', expected_exit_code=0)
def test_test_finder_extension_calls_finder_when_receiving_request(self): config = ConfigManager() config.set(TEST_SOURCES, ['name1', 'name2']) with ExtensionTestHarness(TestFinder, config=config) as harness: expected_result = Mock() # Don't want to run the real finder because it's very hard to get nose to work as intended # inside a unittest with patch('k2.finder.testfinder.Finder.find_tests', return_value=expected_result) as find_tests_mock: actual_tests = harness.send_request( FIND_TEST_CASES, FINDER_ENDPOINT).wait(timeout=1)[0].result(timeout=1) self.assertEqual(expected_result, actual_tests) find_tests_mock.assert_called_with('name1', 'name2')
def test_enabling_using_config(self): config = ConfigManager() config.set(BLOCKER_ENABLED, True) with ExtensionTestHarness( Blocker, endpoints_and_messages={APPLICATION_ENDPOINT: [AFTER_COMMAND]}, config=config) as harness: self.assertTrue(harness.extension._enabled) with ExtensionTestHarness(Blocker, endpoints_and_messages={ TEST_BLOCKER_ENDPOINT: [TEST_BLOCKER_BLOCK], APPLICATION_ENDPOINT: [AFTER_COMMAND] }) as harness: self.assertFalse(harness.extension._enabled)