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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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