def test_execute_job_input_schema_ip_not_found(self):
        # create job template
        fake_job_template = flexmock(
            job_template_type='device',
            job_template_job_runtime='ansible',
            job_template_multi_device_job=False,
            job_template_playbooks=TestJobManagerUtils.
                playbooks_list,
            name='input_schema_template_ip',
            fq_name=["default-global-system-config",
                     "input_schema_template_ip"],
            uuid='random_uuid')

        mock_vnc = flexmock()
        flexmock(VncApi).new_instances(mock_vnc)

        flexmock(mock_vnc).should_receive('job_template_read') \
            .with_args(id="random_uuid") \
            .and_return(fake_job_template)

        TestJobManagerUtils.mock_sandesh_check()

        job_input_json = {
            "job_template_id": "random_uuid",
            "job_execution_id": TestJobManagerUtils.execution_id,
            "fabric_fq_name": "Global-system-config:fabric:1",
            "auth_token": "6e7d7f87faa54fac96a2a28ec752336a",
            "args": TestJobManagerUtils.args
        }
        log_utils = JobLogUtils(
            sandesh_instance_id=TestJobManagerUtils.execution_id,
            config_args=json.dumps(TestJobManagerUtils.args))

        wm = WFManager(log_utils.get_config_logger(),
                          mock_vnc, job_input_json, log_utils)

        fake_schema = TestJobManagerUtils.fake_schema

        fake_job_template.should_receive('get_job_template_input_schema') \
        .and_return(fake_schema)
        fake_job_template.should_receive(
        'get_job_template_multi_device_job') \
        .and_return(False)
        fake_job_template.should_receive('get_uuid').and_return('random_uuid')

        # mock the job_handler to raise an exception
        fake_job_template.should_receive('get_job_template_playbooks')
        sys_exit_msg = self.assertRaises(SystemExit, wm.start_job)
        self.assertEqual(sys_exit_msg.code,
                     MsgBundle.getMessage(MsgBundle.JOB_EXC_REC_HDR) +
                     MsgBundle.getMessage(
                         MsgBundle.INPUT_SCHEMA_INPUT_NOT_FOUND) +
                     " ")
class ObjectLogUtil(object):
    def __init__(self, job_ctx):
        self.job_ctx = job_ctx
        self.results = dict()
        self.results['failed'] = False
        logging.basicConfig(level=logging.INFO)
        self.validate_job_ctx()

        self.job_log_util = JobLogUtils(sandesh_instance_id=str(uuid.uuid4()),
                                        config_args=json.dumps(
                                            job_ctx['config_args']))

    def validate_job_ctx(self):
        required_job_ctx_keys = [
            'job_template_fqname', 'job_execution_id', 'config_args',
            'job_input'
        ]
        for key in required_job_ctx_keys:
            if key not in self.job_ctx or self.job_ctx.get(key) is None:
                raise ValueError("Missing job context param: %s" % key)

    def send_prouter_object_log(self, prouter_fqname, onboarding_state,
                                os_version, serial_num):
        self.job_log_util.send_prouter_object_log(
            prouter_fqname, self.job_ctx['job_execution_id'],
            json.dumps(self.job_ctx['job_input']),
            self.job_ctx['job_template_fqname'], onboarding_state, os_version,
            serial_num)

    def send_job_object_log(self, message, status, job_result):
        self.job_log_util.send_job_log(self.job_ctx['job_template_fqname'],
                                       self.job_ctx['job_execution_id'],
                                       message, status, job_result)

    def close_sandesh_conn(self):
        try:
            sandesh_util = SandeshUtils(self.job_log_util.get_config_logger())
            sandesh_util.close_sandesh_connection()
        except Exception as e:
            logging.error("Unable to close sandesh connection: %s", str(e))