def test_validate_fragment(self): autospec_method(self.manager.load) name = 'the_name' self.manager.validate_fragment(name, self.content) container = self.manager.load.return_value container.add.assert_called_with(name, self.content) container.validate.assert_called_with()
def test_start_no_startable_action_runs(self): autospec_method(self.job_run._do_start) self.job_run.action_runs.has_startable_action_runs = False assert not self.job_run.start() self.job_run.event.info.assert_called_with('start') assert not self.job_run.event.ok.mock_calls
def test_do_start_some_failed(self): returns = [True, None] autospec_method(self.job_run._start_action_runs, return_value=returns) assert self.job_run._do_start() assert_equal(self.job_run.event.ok.call_count, 1) self.job_run.event.ok.assert_called_with('started')
def test_handle_instance_state_change_failed(self): autospec_method(self.service.notify) autospec_method(self.service.record_events) instance_event = serviceinstance.ServiceInstance.STATE_FAILED self.service._handle_instance_state_change(mock.Mock(), instance_event) assert not self.service.notify.mock_calls self.service.record_events.assert_called_with()
def test_handle_instance_state_change_starting(self): autospec_method(self.service.notify) autospec_method(self.service.record_events) instance_event = serviceinstance.ServiceInstance.STATE_STARTING self.service._handle_instance_state_change(mock.Mock(), instance_event) assert not self.service.notify.mock_calls assert not self.service.record_events.mock_calls
def test_handle_action_exit_up(self): self.task.action = mock.create_autospec(ActionCommand) self.task.action.is_failed = False autospec_method(self.task.queue) self.task._handle_action_exit() self.task.notify.assert_called_with(self.task.NOTIFY_UP) self.task.queue.assert_called_with()
def setup_task(self): self.node = mock.create_autospec(node.Node) self.pid_filename = '/tmp/filename' self.task = serviceinstance.ServiceInstanceStopTask( 'id', self.node, self.pid_filename) autospec_method(self.task.watch) autospec_method(self.task.notify)
def test_read_config_no_header(self): name = 'some_name' autospec_method(self.controller._get_config_content) autospec_method(self.controller.render_template) resp = self.controller.read_config(name, add_header=False) assert not self.controller.render_template.called assert_equal(resp['config'], self.controller._get_config_content.return_value)
def test_handle_action_unknown(self): self.task.action = mock.create_autospec(ActionCommand) self.task.action.is_unknown = True autospec_method(self.task.queue) self.task._handle_action_exit() self.task.notify.assert_called_with(self.task.NOTIFY_FAILED) assert_equal(self.task.queue.call_count, 1)
def test_cancel_pending(self): pending_runs = [mock.Mock() for _ in xrange(2)] autospec_method(self.run_collection.get_pending, return_value=pending_runs) self.run_collection.cancel_pending() for pending_run in pending_runs: pending_run.cancel.assert_called_with()
def test_handler_not_end_state_event(self): autospec_method(self.job_run.finalize) autospec_method(self.job_run._start_action_runs) self.action_run.is_done = False self.job_run.handler(self.action_run, mock.Mock()) assert not self.job_run.finalize.mock_calls assert not self.job_run._start_action_runs.mock_calls
def test_load_config(self): autospec_method(self.mcp.apply_config) self.mcp.config = mock.create_autospec(manager.ConfigManager) self.mcp._load_config() self.mcp.state_watcher.disabled.assert_called_with() self.mcp.apply_config.assert_called_with( self.mcp.config.load.return_value, reconfigure=False)
def test_handler_finished_with_cleanup_done(self): self.job_run.action_runs.is_active = False self.job_run.action_runs.is_scheduled = False self.job_run.action_runs.cleanup_action_run = mock.Mock(is_done=True) autospec_method(self.job_run.finalize) self.job_run.handler(self.action_run, mock.Mock()) self.job_run.finalize.assert_called_with()
def test_handler_action_run_skipped(self): self.action_run.is_broken = False self.action_run.is_skipped = True self.job_run.action_runs.is_scheduled = True autospec_method(self.job_run._start_action_runs) self.job_run.handler(self.action_run, mock.Mock()) assert not self.job_run._start_action_runs.mock_calls
def test_stop(self): autospec_method(self.node._fail_run) action_command = mock.create_autospec(actioncommand.ActionCommand, id=mock.Mock()) self.node.run_states[action_command.id] = mock.Mock() self.node.stop(action_command) assert_equal(self.node._fail_run.call_count, 1)
def test_write(self, mock_yaml, mock_open): command, proc = 'do this', mock.Mock() autospec_method(self.status_file.get_content) self.status_file.write(command, proc) self.status_file.get_content.assert_called_with(command, proc) mock_yaml.dump.assert_called_with( self.status_file.get_content.return_value, mock_open.return_value.__enter__.return_value)
def test_handle_action_exit_up(self): self.task.action = mock.create_autospec(ActionCommand) self.task.action.is_failed = False self.task.action.is_unknown = False autospec_method(self.task.queue) self.task._handle_action_exit() self.task.notify.assert_called_with(self.task.NOTIFY_UP) self.task.queue.assert_called_with()
def test_handle_instance_state_change_down(self): autospec_method(self.service.notify) instance_event = serviceinstance.ServiceInstance.STATE_DOWN self.service._handle_instance_state_change(mock.Mock(), instance_event) self.service.notify.assert_called_with( self.service.NOTIFY_STATE_CHANGE, ) self.service.instances.clear_down.assert_called_with()
def test_build_stop_action_command(self): id, command = 'id', 'do a thing' autospec_method(self.factory.build_command) action_command = self.factory.build_stop_action_command(id, command) assert_equal(action_command.id, '%s.%s' % (id, self.factory.build_command.return_value)) assert_equal(action_command.command, self.factory.build_command.return_value)
def test_getChild(self): autospec_method(self.resource.get_run_from_identifier) identifier = 'identifier' resource = self.resource.getChild(identifier, None) assert_equal( resource.job_run, self.resource.get_run_from_identifier.return_value, )
def test_restore_state(self): autospec_method(self.service.watch_instances) autospec_method(self.service.enable) state_data = {'enabled': True, 'instances': []} self.service.restore_state(state_data) self.service.watch_instances.assert_called_with( self.instances.restore_state.return_value) self.service.enable.assert_called_with()
def test_handler_finished_with_cleanup(self): self.job_run.action_runs.is_active = False self.job_run.action_runs.is_scheduled = False self.job_run.action_runs.cleanup_action_run = mock.Mock(is_done=False) autospec_method(self.job_run.finalize) self.job_run.handler(self.action_run, mock.Mock()) assert not self.job_run.finalize.mock_calls self.job_run.action_runs.cleanup_action_run.start.assert_called_with()
def test_connnectionSecure(self): self.transport.connection_defer = mock.Mock() autospec_method(self.transport.requestService) self.transport.connectionSecure() conn = self.transport.connection_defer.mock_calls[0][1][0] assert isinstance(conn, ssh.ClientConnection) auth_service = self.transport.requestService.mock_calls[0][1][0] assert isinstance(auth_service, ssh.NoPasswordAuthClient)
def test_is_done_true_because_blocked(self): self.run_map['action_name'].machine.state = ActionRun.STATE_FAILED self.run_map['second_name'].machine.state = ActionRun.STATE_QUEUED autospec_method(self.collection._is_run_blocked) blocked_second_action_run = lambda ar: ar == self.run_map['second_name'] self.collection._is_run_blocked.side_effect = blocked_second_action_run assert self.collection.is_done assert self.collection.is_failed
def test_replace(self): autospec_method(self.collection.add) item = mock.Mock() self.collection.replace(item) self.collection.add.assert_called_with( item, self.collection.remove_item, )
def test_cancel_pending(self): pending_runs = [mock.Mock() for _ in range(2)] autospec_method( self.run_collection.get_pending, return_value=pending_runs, ) self.run_collection.cancel_pending() for pending_run in pending_runs: pending_run.cancel.assert_called_with()
def test_build_and_sort(self): autospec_method(self.collection.sort) count = 4 builder, seq = mock.Mock(), range(count) instances = self.collection._build_and_sort(builder, seq) self.collection.sort.assert_called_with() assert_equal(builder.mock_calls, [mock.call(i) for i in seq]) assert_length(instances, count) assert_equal(instances, self.collection.instances)
def test_getChild_action_run_history(self): autospec_method(self.resource.get_run_from_identifier, return_value=None) action_name = 'action_name' action_runs = [mock.Mock(), mock.Mock()] self.job.action_graph.names = [action_name] self.job.runs.get_action_runs.return_value = action_runs resource = self.resource.getChild(action_name, None) assert_equal(resource.__class__, www.ActionRunHistoryResource) assert_equal(resource.action_runs, action_runs)
def test_validate_with_fragment(self, mock_config_container): name = 'the_name' name_mapping = {'something': 'content', name: 'old_content'} autospec_method(self.manager.get_config_name_mapping) self.manager.get_config_name_mapping.return_value = name_mapping self.manager.validate_with_fragment(name, self.content) expected_mapping = dict(name_mapping) expected_mapping[name] = self.content mock_config_container.create.assert_called_with(expected_mapping)
def test_stop(self): autospec_method(self.node._fail_run) action_command = mock.create_autospec( actioncommand.ActionCommand, id=mock.Mock(), ) self.node.run_states[action_command.id] = mock.Mock() self.node.stop(action_command) assert_equal(self.node._fail_run.call_count, 1)
def test_create(self): serializer = mock.create_autospec(actioncommand.StringBufferStore) id, command = "id", "do a thing" autospec_method(self.factory.build_command) action_command = self.factory.create(id, command, serializer) assert_equal(action_command.id, id) assert_equal(action_command.command, self.factory.build_command.return_value) assert_equal(action_command.stdout, serializer.open.return_value) assert_equal(action_command.stderr, serializer.open.return_value)
def test_write_config_new_name(self): name = 'filename2' path = self.manager.build_file_path(name) self.manifest.get_file_name.return_value = None autospec_method(self.manager.validate_with_fragment) self.manager.write_config(name, self.raw_content) assert_equal(manager.read(path), self.content) self.manifest.get_file_name.assert_called_with(name) self.manifest.add.assert_called_with(name, path)
def test_load_config(self): autospec_method(self.mcp.apply_config) self.mcp.config = mock.create_autospec(manager.ConfigManager) self.mcp._load_config() self.mcp.state_watcher.disabled.assert_called_with() self.mcp.apply_config.assert_called_with( self.mcp.config.load.return_value, reconfigure=False, )
def test_update(self): mock_scheduler = mock.create_autospec(job.JobScheduler) existing_scheduler = mock.create_autospec(job.JobScheduler) autospec_method(self.collection.get_by_name, return_value=existing_scheduler) assert self.collection.update(mock_scheduler) self.collection.get_by_name.assert_called_with(mock_scheduler.get_name()) existing_scheduler.get_job().update_from_job.assert_called_with( mock_scheduler.get_job.return_value) existing_scheduler.schedule_reconfigured.assert_called_with()
def test_is_done_true_because_blocked(self): self.run_map['action_name'].machine.state = ActionRun.STATE_FAILED self.run_map['second_name'].machine.state = ActionRun.STATE_QUEUED autospec_method(self.collection._is_run_blocked) blocked_second_action_run = lambda ar: ar == self.run_map['second_name' ] self.collection._is_run_blocked.side_effect = blocked_second_action_run assert self.collection.is_done assert self.collection.is_failed
def test_update_from_config_changed(self, mock_factory): state_config = mock.Mock() autospec_method(self.watcher.shutdown) assert self.watcher.update_from_config(state_config) assert_equal(self.watcher.config, state_config) self.watcher.shutdown.assert_called_with() assert_equal(self.watcher.state_manager, mock_factory.from_config.return_value) mock_factory.from_config.assert_called_with(state_config)
def test_cleanup(self): autospec_method(self.job_run.clear_observers) self.job_run.output_path = mock.create_autospec(filehandler.OutputPath) self.job_run.cleanup() self.job_run.clear_observers.assert_called_with() self.job_run.output_path.delete.assert_called_with() assert not self.job_run.node assert not self.job_run.action_graph assert not self.job_run.action_runs
def setup_service(self): self.config = mock.MagicMock() self.instances = mock.create_autospec( serviceinstance.ServiceInstanceCollection, stop=mock.Mock(), start=mock.Mock(), state_data=mock.Mock(), restore=mock.Mock()) self.service = service.Service(self.config, self.instances) autospec_method(self.service.watch) self.service.repair_callback = mock.create_autospec( eventloop.UniqueCallback)
def test_handler_with_startable(self): startable_run = mock.create_autospec(actionrun.ActionRun) self.job_run.action_runs.get_startable_action_runs = lambda: [startable_run] autospec_method(self.job_run.finalize) self.action_run.is_broken = False self.job_run.handler(self.action_run, mock.Mock()) self.job_run.notify.assert_called_with(self.job_run.NOTIFY_STATE_CHANGED) startable_run.start.assert_called_with() assert not self.job_run.finalize.mock_calls
def test_write_config(self): name = 'filename' path = self.manager.build_file_path(name) self.manifest.get_file_name.return_value = path autospec_method(self.manager.validate_fragment) self.manager.write_config(name, self.raw_content) assert_equal(manager.read(path), self.content) self.manifest.get_file_name.assert_called_with(name) assert not self.manifest.add.call_count self.manager.validate_fragment.assert_called_with(name, self.content)
def test_create(self): serializer = mock.create_autospec(actioncommand.StringBufferStore) id, command = 'id', 'do a thing' autospec_method(self.factory.build_command) action_command = self.factory.create(id, command, serializer) assert_equal(action_command.id, id) assert_equal(action_command.command, self.factory.build_command.return_value) assert_equal(action_command.stdout, serializer.open.return_value) assert_equal(action_command.stderr, serializer.open.return_value)
def test_update_config(self): autospec_method(self.controller.strip_header) name, content, config_hash = None, mock.Mock(), mock.Mock() self.manager.get_hash.return_value = config_hash assert not self.controller.update_config(name, content, config_hash) striped_content = self.controller.strip_header.return_value self.manager.write_config.assert_called_with(name, striped_content) self.mcp.reconfigure.assert_called_with() self.controller.strip_header.assert_called_with(name, content) self.manager.get_hash.assert_called_with(name)
def test_build_new_run_manual(self): autospec_method(self.run_collection.remove_old_runs) run_time = datetime.datetime(2012, 3, 14, 15, 9, 26) mock_job = build_mock_job() job_run = self.run_collection.build_new_run( mock_job, run_time, self.mock_node, True) assert_in(job_run, self.run_collection.runs) self.run_collection.remove_old_runs.assert_called_with() assert_equal(job_run.run_num, 5) assert job_run.manual
def test_update(self): mock_scheduler = mock.create_autospec(job.JobScheduler) existing_scheduler = mock.create_autospec(job.JobScheduler) autospec_method(self.collection.get_by_name, return_value=existing_scheduler) assert self.collection.update(mock_scheduler) self.collection.get_by_name.assert_called_with( mock_scheduler.get_name()) existing_scheduler.get_job().update_from_job.assert_called_with( mock_scheduler.get_job.return_value) existing_scheduler.schedule_reconfigured.assert_called_with()
def test_update_config_failure(self): autospec_method(self.controller.strip_header) striped_content = self.controller.strip_header.return_value name, content, config_hash = None, mock.Mock(), mock.Mock() self.manager.get_hash.return_value = config_hash self.manager.write_config.side_effect = ConfigError("It broke") error = self.controller.update_config(name, striped_content, config_hash) assert_equal(error, "It broke") self.manager.write_config.assert_called_with(name, striped_content) assert not self.mcp.reconfigure.call_count
def test_read_config_named(self): name = 'some_name' autospec_method(self.controller._get_config_content) autospec_method(self.controller.render_template) resp = self.controller.read_config(name) self.controller._get_config_content.assert_called_with(name) self.controller.render_template.assert_called_with( self.controller._get_config_content.return_value) assert_equal(resp['config'], self.controller.render_template.return_value) assert_equal(resp['hash'], self.manager.get_hash.return_value)
def test_is_done_true_because_blocked(self): self.run_map['action_name'].machine.state = ActionRun.FAILED self.run_map['second_name'].machine.state = ActionRun.QUEUED autospec_method(self.collection._is_run_blocked) def blocked_second_action_run(ar, ): return ar == self.run_map['second_name'] self.collection._is_run_blocked.side_effect = blocked_second_action_run assert self.collection.is_done assert self.collection.is_failed
def test_build_action_command(self, mock_filehandler): autospec_method(self.action_run.watch) serializer = mock_filehandler.OutputStreamSerializer.return_value action_command = self.action_run.build_action_command() assert_equal(action_command, self.action_run.action_command) assert_equal(action_command, self.action_runner.create.return_value) self.action_runner.create.assert_called_with(self.action_run.id, self.action_run.command, serializer) mock_filehandler.OutputStreamSerializer.assert_called_with( self.action_run.output_path) self.action_run.watch.assert_called_with(action_command)