// Code generated by lark_sdk_gen. DO NOT EDIT.
/**
 * Copyright 2022 chyroc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package test

import (
	"context"
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"

	"github.com/chyroc/lark"
)

func Test_Hire_Sample_Failed(t *testing.T) {
	as := assert.New(t)

	t.Run("request failed", func(t *testing.T) {
		cli := AppAllPermission.Ins()
		cli.Mock().MockGetTenantAccessToken(mockGetTenantAccessTokenFailed)
		cli.Mock().MockGetAppAccessToken(mockGetTenantAccessTokenFailed)
		moduleCli := cli.Hire

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJobConfig(ctx, &lark.GetHireJobConfigReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "failed")
		})

	})

	t.Run("request mock failed", func(t *testing.T) {
		cli := AppAllPermission.Ins()
		moduleCli := cli.Hire

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireJobConfig(func(ctx context.Context, request *lark.GetHireJobConfigReq, options ...lark.MethodOptionFunc) (*lark.GetHireJobConfigResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireJobConfig()

			_, _, err := moduleCli.GetHireJobConfig(ctx, &lark.GetHireJobConfigReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireJob(func(ctx context.Context, request *lark.CreateHireJobReq, options ...lark.MethodOptionFunc) (*lark.CreateHireJobResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireJob()

			_, _, err := moduleCli.CreateHireJob(ctx, &lark.CreateHireJobReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireJob(func(ctx context.Context, request *lark.UpdateHireJobReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireJobResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireJob()

			_, _, err := moduleCli.UpdateHireJob(ctx, &lark.UpdateHireJobReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireJobConfig(func(ctx context.Context, request *lark.UpdateHireJobConfigReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireJobConfigResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireJobConfig()

			_, _, err := moduleCli.UpdateHireJobConfig(ctx, &lark.UpdateHireJobConfigReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireJob(func(ctx context.Context, request *lark.GetHireJobReq, options ...lark.MethodOptionFunc) (*lark.GetHireJobResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireJob()

			_, _, err := moduleCli.GetHireJob(ctx, &lark.GetHireJobReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireJobManager(func(ctx context.Context, request *lark.GetHireJobManagerReq, options ...lark.MethodOptionFunc) (*lark.GetHireJobManagerResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireJobManager()

			_, _, err := moduleCli.GetHireJobManager(ctx, &lark.GetHireJobManagerReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireQueryHireTalentObject(func(ctx context.Context, request *lark.QueryHireTalentObjectReq, options ...lark.MethodOptionFunc) (*lark.QueryHireTalentObjectResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireQueryHireTalentObject()

			_, _, err := moduleCli.QueryHireTalentObject(ctx, &lark.QueryHireTalentObjectReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireTalent(func(ctx context.Context, request *lark.GetHireTalentReq, options ...lark.MethodOptionFunc) (*lark.GetHireTalentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireTalent()

			_, _, err := moduleCli.GetHireTalent(ctx, &lark.GetHireTalentReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireAttachment(func(ctx context.Context, request *lark.GetHireAttachmentReq, options ...lark.MethodOptionFunc) (*lark.GetHireAttachmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireAttachment()

			_, _, err := moduleCli.GetHireAttachment(ctx, &lark.GetHireAttachmentReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireAttachmentPreview(func(ctx context.Context, request *lark.GetHireAttachmentPreviewReq, options ...lark.MethodOptionFunc) (*lark.GetHireAttachmentPreviewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireAttachmentPreview()

			_, _, err := moduleCli.GetHireAttachmentPreview(ctx, &lark.GetHireAttachmentPreviewReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireReferralWebsiteJobPostList(func(ctx context.Context, request *lark.GetHireReferralWebsiteJobPostListReq, options ...lark.MethodOptionFunc) (*lark.GetHireReferralWebsiteJobPostListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireReferralWebsiteJobPostList()

			_, _, err := moduleCli.GetHireReferralWebsiteJobPostList(ctx, &lark.GetHireReferralWebsiteJobPostListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireReferralWebsiteJobPost(func(ctx context.Context, request *lark.GetHireReferralWebsiteJobPostReq, options ...lark.MethodOptionFunc) (*lark.GetHireReferralWebsiteJobPostResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireReferralWebsiteJobPost()

			_, _, err := moduleCli.GetHireReferralWebsiteJobPost(ctx, &lark.GetHireReferralWebsiteJobPostReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireReferralByApplication(func(ctx context.Context, request *lark.GetHireReferralByApplicationReq, options ...lark.MethodOptionFunc) (*lark.GetHireReferralByApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireReferralByApplication()

			_, _, err := moduleCli.GetHireReferralByApplication(ctx, &lark.GetHireReferralByApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireExternalApplication(func(ctx context.Context, request *lark.CreateHireExternalApplicationReq, options ...lark.MethodOptionFunc) (*lark.CreateHireExternalApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireExternalApplication()

			_, _, err := moduleCli.CreateHireExternalApplication(ctx, &lark.CreateHireExternalApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireExternalApplication(func(ctx context.Context, request *lark.UpdateHireExternalApplicationReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireExternalApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireExternalApplication()

			_, _, err := moduleCli.UpdateHireExternalApplication(ctx, &lark.UpdateHireExternalApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireDeleteHireExternalApplication(func(ctx context.Context, request *lark.DeleteHireExternalApplicationReq, options ...lark.MethodOptionFunc) (*lark.DeleteHireExternalApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireDeleteHireExternalApplication()

			_, _, err := moduleCli.DeleteHireExternalApplication(ctx, &lark.DeleteHireExternalApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireExternalInterview(func(ctx context.Context, request *lark.CreateHireExternalInterviewReq, options ...lark.MethodOptionFunc) (*lark.CreateHireExternalInterviewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireExternalInterview()

			_, _, err := moduleCli.CreateHireExternalInterview(ctx, &lark.CreateHireExternalInterviewReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireExternalInterviewAssessment(func(ctx context.Context, request *lark.CreateHireExternalInterviewAssessmentReq, options ...lark.MethodOptionFunc) (*lark.CreateHireExternalInterviewAssessmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireExternalInterviewAssessment()

			_, _, err := moduleCli.CreateHireExternalInterviewAssessment(ctx, &lark.CreateHireExternalInterviewAssessmentReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireExternalBackgroundCheck(func(ctx context.Context, request *lark.CreateHireExternalBackgroundCheckReq, options ...lark.MethodOptionFunc) (*lark.CreateHireExternalBackgroundCheckResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireExternalBackgroundCheck()

			_, _, err := moduleCli.CreateHireExternalBackgroundCheck(ctx, &lark.CreateHireExternalBackgroundCheckReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireAddHireTalentToFolder(func(ctx context.Context, request *lark.AddHireTalentToFolderReq, options ...lark.MethodOptionFunc) (*lark.AddHireTalentToFolderResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireAddHireTalentToFolder()

			_, _, err := moduleCli.AddHireTalentToFolder(ctx, &lark.AddHireTalentToFolderReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireTalentFolderList(func(ctx context.Context, request *lark.GetHireTalentFolderListReq, options ...lark.MethodOptionFunc) (*lark.GetHireTalentFolderListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireTalentFolderList()

			_, _, err := moduleCli.GetHireTalentFolderList(ctx, &lark.GetHireTalentFolderListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchGetHireTalent(func(ctx context.Context, request *lark.BatchGetHireTalentReq, options ...lark.MethodOptionFunc) (*lark.BatchGetHireTalentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchGetHireTalent()

			_, _, err := moduleCli.BatchGetHireTalent(ctx, &lark.BatchGetHireTalentReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireTalentList(func(ctx context.Context, request *lark.GetHireTalentListReq, options ...lark.MethodOptionFunc) (*lark.GetHireTalentListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireTalentList()

			_, _, err := moduleCli.GetHireTalentList(ctx, &lark.GetHireTalentListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireJobProcessList(func(ctx context.Context, request *lark.GetHireJobProcessListReq, options ...lark.MethodOptionFunc) (*lark.GetHireJobProcessListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireJobProcessList()

			_, _, err := moduleCli.GetHireJobProcessList(ctx, &lark.GetHireJobProcessListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireApplication(func(ctx context.Context, request *lark.CreateHireApplicationReq, options ...lark.MethodOptionFunc) (*lark.CreateHireApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireApplication()

			_, _, err := moduleCli.CreateHireApplication(ctx, &lark.CreateHireApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireTerminateHireApplication(func(ctx context.Context, request *lark.TerminateHireApplicationReq, options ...lark.MethodOptionFunc) (*lark.TerminateHireApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireTerminateHireApplication()

			_, _, err := moduleCli.TerminateHireApplication(ctx, &lark.TerminateHireApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireApplication(func(ctx context.Context, request *lark.GetHireApplicationReq, options ...lark.MethodOptionFunc) (*lark.GetHireApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireApplication()

			_, _, err := moduleCli.GetHireApplication(ctx, &lark.GetHireApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireApplicationList(func(ctx context.Context, request *lark.GetHireApplicationListReq, options ...lark.MethodOptionFunc) (*lark.GetHireApplicationListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireApplicationList()

			_, _, err := moduleCli.GetHireApplicationList(ctx, &lark.GetHireApplicationListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireEvaluationList(func(ctx context.Context, request *lark.GetHireEvaluationListReq, options ...lark.MethodOptionFunc) (*lark.GetHireEvaluationListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireEvaluationList()

			_, _, err := moduleCli.GetHireEvaluationList(ctx, &lark.GetHireEvaluationListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireQuestionnaireList(func(ctx context.Context, request *lark.GetHireQuestionnaireListReq, options ...lark.MethodOptionFunc) (*lark.GetHireQuestionnaireListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireQuestionnaireList()

			_, _, err := moduleCli.GetHireQuestionnaireList(ctx, &lark.GetHireQuestionnaireListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireInterviewList(func(ctx context.Context, request *lark.GetHireInterviewListReq, options ...lark.MethodOptionFunc) (*lark.GetHireInterviewListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireInterviewList()

			_, _, err := moduleCli.GetHireInterviewList(ctx, &lark.GetHireInterviewListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireOffer(func(ctx context.Context, request *lark.CreateHireOfferReq, options ...lark.MethodOptionFunc) (*lark.CreateHireOfferResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireOffer()

			_, _, err := moduleCli.CreateHireOffer(ctx, &lark.CreateHireOfferReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireOffer(func(ctx context.Context, request *lark.UpdateHireOfferReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireOfferResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireOffer()

			_, _, err := moduleCli.UpdateHireOffer(ctx, &lark.UpdateHireOfferReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireOfferByApplication(func(ctx context.Context, request *lark.GetHireOfferByApplicationReq, options ...lark.MethodOptionFunc) (*lark.GetHireOfferByApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireOfferByApplication()

			_, _, err := moduleCli.GetHireOfferByApplication(ctx, &lark.GetHireOfferByApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireOffer(func(ctx context.Context, request *lark.GetHireOfferReq, options ...lark.MethodOptionFunc) (*lark.GetHireOfferResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireOffer()

			_, _, err := moduleCli.GetHireOffer(ctx, &lark.GetHireOfferReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireOfferList(func(ctx context.Context, request *lark.GetHireOfferListReq, options ...lark.MethodOptionFunc) (*lark.GetHireOfferListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireOfferList()

			_, _, err := moduleCli.GetHireOfferList(ctx, &lark.GetHireOfferListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireOfferStatus(func(ctx context.Context, request *lark.UpdateHireOfferStatusReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireOfferStatusResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireOfferStatus()

			_, _, err := moduleCli.UpdateHireOfferStatus(ctx, &lark.UpdateHireOfferStatusReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireOfferInternStatus(func(ctx context.Context, request *lark.UpdateHireOfferInternStatusReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireOfferInternStatusResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireOfferInternStatus()

			_, _, err := moduleCli.UpdateHireOfferInternStatus(ctx, &lark.UpdateHireOfferInternStatusReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireApplicationInterviewList(func(ctx context.Context, request *lark.GetHireApplicationInterviewListReq, options ...lark.MethodOptionFunc) (*lark.GetHireApplicationInterviewListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireApplicationInterviewList()

			_, _, err := moduleCli.GetHireApplicationInterviewList(ctx, &lark.GetHireApplicationInterviewListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireOfferSchema(func(ctx context.Context, request *lark.GetHireOfferSchemaReq, options ...lark.MethodOptionFunc) (*lark.GetHireOfferSchemaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireOfferSchema()

			_, _, err := moduleCli.GetHireOfferSchema(ctx, &lark.GetHireOfferSchemaReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireEHRImportTask(func(ctx context.Context, request *lark.UpdateHireEHRImportTaskReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireEHRImportTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireEHRImportTask()

			_, _, err := moduleCli.UpdateHireEHRImportTask(ctx, &lark.UpdateHireEHRImportTaskReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireMakeHireTransferOnboardByApplication(func(ctx context.Context, request *lark.MakeHireTransferOnboardByApplicationReq, options ...lark.MethodOptionFunc) (*lark.MakeHireTransferOnboardByApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireMakeHireTransferOnboardByApplication()

			_, _, err := moduleCli.MakeHireTransferOnboardByApplication(ctx, &lark.MakeHireTransferOnboardByApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireEmployee(func(ctx context.Context, request *lark.UpdateHireEmployeeReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireEmployeeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireEmployee()

			_, _, err := moduleCli.UpdateHireEmployee(ctx, &lark.UpdateHireEmployeeReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireEmployeeByApplication(func(ctx context.Context, request *lark.GetHireEmployeeByApplicationReq, options ...lark.MethodOptionFunc) (*lark.GetHireEmployeeByApplicationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireEmployeeByApplication()

			_, _, err := moduleCli.GetHireEmployeeByApplication(ctx, &lark.GetHireEmployeeByApplicationReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireEmployee(func(ctx context.Context, request *lark.GetHireEmployeeReq, options ...lark.MethodOptionFunc) (*lark.GetHireEmployeeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireEmployee()

			_, _, err := moduleCli.GetHireEmployee(ctx, &lark.GetHireEmployeeReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireNote(func(ctx context.Context, request *lark.CreateHireNoteReq, options ...lark.MethodOptionFunc) (*lark.CreateHireNoteResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireNote()

			_, _, err := moduleCli.CreateHireNote(ctx, &lark.CreateHireNoteReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireNote(func(ctx context.Context, request *lark.UpdateHireNoteReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireNoteResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireNote()

			_, _, err := moduleCli.UpdateHireNote(ctx, &lark.UpdateHireNoteReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireNote(func(ctx context.Context, request *lark.GetHireNoteReq, options ...lark.MethodOptionFunc) (*lark.GetHireNoteResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireNote()

			_, _, err := moduleCli.GetHireNote(ctx, &lark.GetHireNoteReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireNoteList(func(ctx context.Context, request *lark.GetHireNoteListReq, options ...lark.MethodOptionFunc) (*lark.GetHireNoteListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireNoteList()

			_, _, err := moduleCli.GetHireNoteList(ctx, &lark.GetHireNoteListReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireGetHireResumeSource(func(ctx context.Context, request *lark.GetHireResumeSourceReq, options ...lark.MethodOptionFunc) (*lark.GetHireResumeSourceResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireGetHireResumeSource()

			_, _, err := moduleCli.GetHireResumeSource(ctx, &lark.GetHireResumeSourceReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireEcoAccountCustomField(func(ctx context.Context, request *lark.CreateHireEcoAccountCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.CreateHireEcoAccountCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireEcoAccountCustomField()

			_, _, err := moduleCli.CreateHireEcoAccountCustomField(ctx, &lark.CreateHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchUpdateHireEcoAccountCustomField(func(ctx context.Context, request *lark.BatchUpdateHireEcoAccountCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.BatchUpdateHireEcoAccountCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchUpdateHireEcoAccountCustomField()

			_, _, err := moduleCli.BatchUpdateHireEcoAccountCustomField(ctx, &lark.BatchUpdateHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchDeleteHireEcoAccountCustomField(func(ctx context.Context, request *lark.BatchDeleteHireEcoAccountCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteHireEcoAccountCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchDeleteHireEcoAccountCustomField()

			_, _, err := moduleCli.BatchDeleteHireEcoAccountCustomField(ctx, &lark.BatchDeleteHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireEcoBackgroundCheckCustomField(func(ctx context.Context, request *lark.CreateHireEcoBackgroundCheckCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.CreateHireEcoBackgroundCheckCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireEcoBackgroundCheckCustomField()

			_, _, err := moduleCli.CreateHireEcoBackgroundCheckCustomField(ctx, &lark.CreateHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchUpdateHireEcoBackgroundCheckCustomField(func(ctx context.Context, request *lark.BatchUpdateHireEcoBackgroundCheckCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.BatchUpdateHireEcoBackgroundCheckCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchUpdateHireEcoBackgroundCheckCustomField()

			_, _, err := moduleCli.BatchUpdateHireEcoBackgroundCheckCustomField(ctx, &lark.BatchUpdateHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchDeleteHireEcoBackgroundCheckCustomField(func(ctx context.Context, request *lark.BatchDeleteHireEcoBackgroundCheckCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteHireEcoBackgroundCheckCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchDeleteHireEcoBackgroundCheckCustomField()

			_, _, err := moduleCli.BatchDeleteHireEcoBackgroundCheckCustomField(ctx, &lark.BatchDeleteHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireEcoBackgroundCheckPackage(func(ctx context.Context, request *lark.CreateHireEcoBackgroundCheckPackageReq, options ...lark.MethodOptionFunc) (*lark.CreateHireEcoBackgroundCheckPackageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireEcoBackgroundCheckPackage()

			_, _, err := moduleCli.CreateHireEcoBackgroundCheckPackage(ctx, &lark.CreateHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchUpdateHireEcoBackgroundCheckPackage(func(ctx context.Context, request *lark.BatchUpdateHireEcoBackgroundCheckPackageReq, options ...lark.MethodOptionFunc) (*lark.BatchUpdateHireEcoBackgroundCheckPackageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchUpdateHireEcoBackgroundCheckPackage()

			_, _, err := moduleCli.BatchUpdateHireEcoBackgroundCheckPackage(ctx, &lark.BatchUpdateHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchDeleteHireEcoBackgroundCheckPackage(func(ctx context.Context, request *lark.BatchDeleteHireEcoBackgroundCheckPackageReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteHireEcoBackgroundCheckPackageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchDeleteHireEcoBackgroundCheckPackage()

			_, _, err := moduleCli.BatchDeleteHireEcoBackgroundCheckPackage(ctx, &lark.BatchDeleteHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireEcoBackgroundCheckProgress(func(ctx context.Context, request *lark.UpdateHireEcoBackgroundCheckProgressReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireEcoBackgroundCheckProgressResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireEcoBackgroundCheckProgress()

			_, _, err := moduleCli.UpdateHireEcoBackgroundCheckProgress(ctx, &lark.UpdateHireEcoBackgroundCheckProgressReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHireEcoBackgroundCheckResult(func(ctx context.Context, request *lark.UpdateHireEcoBackgroundCheckResultReq, options ...lark.MethodOptionFunc) (*lark.UpdateHireEcoBackgroundCheckResultResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHireEcoBackgroundCheckResult()

			_, _, err := moduleCli.UpdateHireEcoBackgroundCheckResult(ctx, &lark.UpdateHireEcoBackgroundCheckResultReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCancelHireEcoBackgroundCheck(func(ctx context.Context, request *lark.CancelHireEcoBackgroundCheckReq, options ...lark.MethodOptionFunc) (*lark.CancelHireEcoBackgroundCheckResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCancelHireEcoBackgroundCheck()

			_, _, err := moduleCli.CancelHireEcoBackgroundCheck(ctx, &lark.CancelHireEcoBackgroundCheckReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireEcoExamPaper(func(ctx context.Context, request *lark.CreateHireEcoExamPaperReq, options ...lark.MethodOptionFunc) (*lark.CreateHireEcoExamPaperResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireEcoExamPaper()

			_, _, err := moduleCli.CreateHireEcoExamPaper(ctx, &lark.CreateHireEcoExamPaperReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchUpdateHireEcoExamPaper(func(ctx context.Context, request *lark.BatchUpdateHireEcoExamPaperReq, options ...lark.MethodOptionFunc) (*lark.BatchUpdateHireEcoExamPaperResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchUpdateHireEcoExamPaper()

			_, _, err := moduleCli.BatchUpdateHireEcoExamPaper(ctx, &lark.BatchUpdateHireEcoExamPaperReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireBatchDeleteHireEcoExamPaper(func(ctx context.Context, request *lark.BatchDeleteHireEcoExamPaperReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteHireEcoExamPaperResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireBatchDeleteHireEcoExamPaper()

			_, _, err := moduleCli.BatchDeleteHireEcoExamPaper(ctx, &lark.BatchDeleteHireEcoExamPaperReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireEcoExamLoginInfo(func(ctx context.Context, request *lark.CreateHireEcoExamLoginInfoReq, options ...lark.MethodOptionFunc) (*lark.CreateHireEcoExamLoginInfoResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireEcoExamLoginInfo()

			_, _, err := moduleCli.CreateHireEcoExamLoginInfo(ctx, &lark.CreateHireEcoExamLoginInfoReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireUpdateHiredEcoExamResult(func(ctx context.Context, request *lark.UpdateHiredEcoExamResultReq, options ...lark.MethodOptionFunc) (*lark.UpdateHiredEcoExamResultResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireUpdateHiredEcoExamResult()

			_, _, err := moduleCli.UpdateHiredEcoExamResult(ctx, &lark.UpdateHiredEcoExamResultReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireCreateHireReferralAccount(func(ctx context.Context, request *lark.CreateHireReferralAccountReq, options ...lark.MethodOptionFunc) (*lark.CreateHireReferralAccountResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireCreateHireReferralAccount()

			_, _, err := moduleCli.CreateHireReferralAccount(ctx, &lark.CreateHireReferralAccountReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireDeactivateHireReferralAccount(func(ctx context.Context, request *lark.DeactivateHireReferralAccountReq, options ...lark.MethodOptionFunc) (*lark.DeactivateHireReferralAccountResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireDeactivateHireReferralAccount()

			_, _, err := moduleCli.DeactivateHireReferralAccount(ctx, &lark.DeactivateHireReferralAccountReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireWithdrawHireReferralAccount(func(ctx context.Context, request *lark.WithdrawHireReferralAccountReq, options ...lark.MethodOptionFunc) (*lark.WithdrawHireReferralAccountResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireWithdrawHireReferralAccount()

			_, _, err := moduleCli.WithdrawHireReferralAccount(ctx, &lark.WithdrawHireReferralAccountReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

		t.Run("", func(t *testing.T) {

			cli.Mock().MockHireReconcileHireReferralAccount(func(ctx context.Context, request *lark.ReconcileHireReferralAccountReq, options ...lark.MethodOptionFunc) (*lark.ReconcileHireReferralAccountResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockHireReconcileHireReferralAccount()

			_, _, err := moduleCli.ReconcileHireReferralAccount(ctx, &lark.ReconcileHireReferralAccountReq{})
			as.NotNil(err)
			as.Equal(err.Error(), "mock-failed")
		})

	})

	t.Run("response is failed", func(t *testing.T) {
		cli := AppNoPermission.Ins()
		moduleCli := cli.Hire

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJobConfig(ctx, &lark.GetHireJobConfigReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireJob(ctx, &lark.CreateHireJobReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireJob(ctx, &lark.UpdateHireJobReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireJobConfig(ctx, &lark.UpdateHireJobConfigReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJob(ctx, &lark.GetHireJobReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJobManager(ctx, &lark.GetHireJobManagerReq{
				JobID:     "x",
				ManagerID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.QueryHireTalentObject(ctx, &lark.QueryHireTalentObjectReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireTalent(ctx, &lark.GetHireTalentReq{
				TalentID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireAttachment(ctx, &lark.GetHireAttachmentReq{
				AttachmentID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireAttachmentPreview(ctx, &lark.GetHireAttachmentPreviewReq{
				AttachmentID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireReferralWebsiteJobPostList(ctx, &lark.GetHireReferralWebsiteJobPostListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireReferralWebsiteJobPost(ctx, &lark.GetHireReferralWebsiteJobPostReq{
				JobPostID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireReferralByApplication(ctx, &lark.GetHireReferralByApplicationReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalApplication(ctx, &lark.CreateHireExternalApplicationReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireExternalApplication(ctx, &lark.UpdateHireExternalApplicationReq{
				ExternalApplicationID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.DeleteHireExternalApplication(ctx, &lark.DeleteHireExternalApplicationReq{
				ExternalApplicationID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalInterview(ctx, &lark.CreateHireExternalInterviewReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalInterviewAssessment(ctx, &lark.CreateHireExternalInterviewAssessmentReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalBackgroundCheck(ctx, &lark.CreateHireExternalBackgroundCheckReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.AddHireTalentToFolder(ctx, &lark.AddHireTalentToFolderReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireTalentFolderList(ctx, &lark.GetHireTalentFolderListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchGetHireTalent(ctx, &lark.BatchGetHireTalentReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireTalentList(ctx, &lark.GetHireTalentListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJobProcessList(ctx, &lark.GetHireJobProcessListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireApplication(ctx, &lark.CreateHireApplicationReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.TerminateHireApplication(ctx, &lark.TerminateHireApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireApplication(ctx, &lark.GetHireApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireApplicationList(ctx, &lark.GetHireApplicationListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireEvaluationList(ctx, &lark.GetHireEvaluationListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireQuestionnaireList(ctx, &lark.GetHireQuestionnaireListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireInterviewList(ctx, &lark.GetHireInterviewListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireOffer(ctx, &lark.CreateHireOfferReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireOffer(ctx, &lark.UpdateHireOfferReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOfferByApplication(ctx, &lark.GetHireOfferByApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOffer(ctx, &lark.GetHireOfferReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOfferList(ctx, &lark.GetHireOfferListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireOfferStatus(ctx, &lark.UpdateHireOfferStatusReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireOfferInternStatus(ctx, &lark.UpdateHireOfferInternStatusReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireApplicationInterviewList(ctx, &lark.GetHireApplicationInterviewListReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOfferSchema(ctx, &lark.GetHireOfferSchemaReq{
				OfferSchemaID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEHRImportTask(ctx, &lark.UpdateHireEHRImportTaskReq{
				EHRImportTaskID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.MakeHireTransferOnboardByApplication(ctx, &lark.MakeHireTransferOnboardByApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEmployee(ctx, &lark.UpdateHireEmployeeReq{
				EmployeeID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireEmployeeByApplication(ctx, &lark.GetHireEmployeeByApplicationReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireEmployee(ctx, &lark.GetHireEmployeeReq{
				EmployeeID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireNote(ctx, &lark.CreateHireNoteReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireNote(ctx, &lark.UpdateHireNoteReq{
				NoteID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireNote(ctx, &lark.GetHireNoteReq{
				NoteID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireNoteList(ctx, &lark.GetHireNoteListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireResumeSource(ctx, &lark.GetHireResumeSourceReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoAccountCustomField(ctx, &lark.CreateHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoAccountCustomField(ctx, &lark.BatchUpdateHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoAccountCustomField(ctx, &lark.BatchDeleteHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoBackgroundCheckCustomField(ctx, &lark.CreateHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoBackgroundCheckCustomField(ctx, &lark.BatchUpdateHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoBackgroundCheckCustomField(ctx, &lark.BatchDeleteHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoBackgroundCheckPackage(ctx, &lark.CreateHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoBackgroundCheckPackage(ctx, &lark.BatchUpdateHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoBackgroundCheckPackage(ctx, &lark.BatchDeleteHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEcoBackgroundCheckProgress(ctx, &lark.UpdateHireEcoBackgroundCheckProgressReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEcoBackgroundCheckResult(ctx, &lark.UpdateHireEcoBackgroundCheckResultReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CancelHireEcoBackgroundCheck(ctx, &lark.CancelHireEcoBackgroundCheckReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoExamPaper(ctx, &lark.CreateHireEcoExamPaperReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoExamPaper(ctx, &lark.BatchUpdateHireEcoExamPaperReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoExamPaper(ctx, &lark.BatchDeleteHireEcoExamPaperReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoExamLoginInfo(ctx, &lark.CreateHireEcoExamLoginInfoReq{
				ExamID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHiredEcoExamResult(ctx, &lark.UpdateHiredEcoExamResultReq{
				ExamID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireReferralAccount(ctx, &lark.CreateHireReferralAccountReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.DeactivateHireReferralAccount(ctx, &lark.DeactivateHireReferralAccountReq{
				ReferralAccountID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.WithdrawHireReferralAccount(ctx, &lark.WithdrawHireReferralAccountReq{
				ReferralAccountID: "x",
			})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.ReconcileHireReferralAccount(ctx, &lark.ReconcileHireReferralAccountReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

	})

	t.Run("fake request is failed", func(t *testing.T) {
		cli := AppAllPermission.Ins()
		moduleCli := cli.Hire
		cli.Mock().MockRawRequest(func(ctx context.Context, req *lark.RawRequestReq, resp interface{}) (response *lark.Response, err error) {
			return nil, fmt.Errorf("fake raw request")
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJobConfig(ctx, &lark.GetHireJobConfigReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireJob(ctx, &lark.CreateHireJobReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireJob(ctx, &lark.UpdateHireJobReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireJobConfig(ctx, &lark.UpdateHireJobConfigReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJob(ctx, &lark.GetHireJobReq{
				JobID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJobManager(ctx, &lark.GetHireJobManagerReq{
				JobID:     "x",
				ManagerID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.QueryHireTalentObject(ctx, &lark.QueryHireTalentObjectReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireTalent(ctx, &lark.GetHireTalentReq{
				TalentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireAttachment(ctx, &lark.GetHireAttachmentReq{
				AttachmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireAttachmentPreview(ctx, &lark.GetHireAttachmentPreviewReq{
				AttachmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireReferralWebsiteJobPostList(ctx, &lark.GetHireReferralWebsiteJobPostListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireReferralWebsiteJobPost(ctx, &lark.GetHireReferralWebsiteJobPostReq{
				JobPostID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireReferralByApplication(ctx, &lark.GetHireReferralByApplicationReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalApplication(ctx, &lark.CreateHireExternalApplicationReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireExternalApplication(ctx, &lark.UpdateHireExternalApplicationReq{
				ExternalApplicationID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.DeleteHireExternalApplication(ctx, &lark.DeleteHireExternalApplicationReq{
				ExternalApplicationID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalInterview(ctx, &lark.CreateHireExternalInterviewReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalInterviewAssessment(ctx, &lark.CreateHireExternalInterviewAssessmentReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireExternalBackgroundCheck(ctx, &lark.CreateHireExternalBackgroundCheckReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.AddHireTalentToFolder(ctx, &lark.AddHireTalentToFolderReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireTalentFolderList(ctx, &lark.GetHireTalentFolderListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchGetHireTalent(ctx, &lark.BatchGetHireTalentReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireTalentList(ctx, &lark.GetHireTalentListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireJobProcessList(ctx, &lark.GetHireJobProcessListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireApplication(ctx, &lark.CreateHireApplicationReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.TerminateHireApplication(ctx, &lark.TerminateHireApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireApplication(ctx, &lark.GetHireApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireApplicationList(ctx, &lark.GetHireApplicationListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireEvaluationList(ctx, &lark.GetHireEvaluationListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireQuestionnaireList(ctx, &lark.GetHireQuestionnaireListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireInterviewList(ctx, &lark.GetHireInterviewListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireOffer(ctx, &lark.CreateHireOfferReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireOffer(ctx, &lark.UpdateHireOfferReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOfferByApplication(ctx, &lark.GetHireOfferByApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOffer(ctx, &lark.GetHireOfferReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOfferList(ctx, &lark.GetHireOfferListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireOfferStatus(ctx, &lark.UpdateHireOfferStatusReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireOfferInternStatus(ctx, &lark.UpdateHireOfferInternStatusReq{
				OfferID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireApplicationInterviewList(ctx, &lark.GetHireApplicationInterviewListReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireOfferSchema(ctx, &lark.GetHireOfferSchemaReq{
				OfferSchemaID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEHRImportTask(ctx, &lark.UpdateHireEHRImportTaskReq{
				EHRImportTaskID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.MakeHireTransferOnboardByApplication(ctx, &lark.MakeHireTransferOnboardByApplicationReq{
				ApplicationID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEmployee(ctx, &lark.UpdateHireEmployeeReq{
				EmployeeID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireEmployeeByApplication(ctx, &lark.GetHireEmployeeByApplicationReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireEmployee(ctx, &lark.GetHireEmployeeReq{
				EmployeeID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireNote(ctx, &lark.CreateHireNoteReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireNote(ctx, &lark.UpdateHireNoteReq{
				NoteID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireNote(ctx, &lark.GetHireNoteReq{
				NoteID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireNoteList(ctx, &lark.GetHireNoteListReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.GetHireResumeSource(ctx, &lark.GetHireResumeSourceReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoAccountCustomField(ctx, &lark.CreateHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoAccountCustomField(ctx, &lark.BatchUpdateHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoAccountCustomField(ctx, &lark.BatchDeleteHireEcoAccountCustomFieldReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoBackgroundCheckCustomField(ctx, &lark.CreateHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoBackgroundCheckCustomField(ctx, &lark.BatchUpdateHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoBackgroundCheckCustomField(ctx, &lark.BatchDeleteHireEcoBackgroundCheckCustomFieldReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoBackgroundCheckPackage(ctx, &lark.CreateHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoBackgroundCheckPackage(ctx, &lark.BatchUpdateHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoBackgroundCheckPackage(ctx, &lark.BatchDeleteHireEcoBackgroundCheckPackageReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEcoBackgroundCheckProgress(ctx, &lark.UpdateHireEcoBackgroundCheckProgressReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHireEcoBackgroundCheckResult(ctx, &lark.UpdateHireEcoBackgroundCheckResultReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CancelHireEcoBackgroundCheck(ctx, &lark.CancelHireEcoBackgroundCheckReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoExamPaper(ctx, &lark.CreateHireEcoExamPaperReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchUpdateHireEcoExamPaper(ctx, &lark.BatchUpdateHireEcoExamPaperReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.BatchDeleteHireEcoExamPaper(ctx, &lark.BatchDeleteHireEcoExamPaperReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireEcoExamLoginInfo(ctx, &lark.CreateHireEcoExamLoginInfoReq{
				ExamID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.UpdateHiredEcoExamResult(ctx, &lark.UpdateHiredEcoExamResultReq{
				ExamID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.CreateHireReferralAccount(ctx, &lark.CreateHireReferralAccountReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.DeactivateHireReferralAccount(ctx, &lark.DeactivateHireReferralAccountReq{
				ReferralAccountID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.WithdrawHireReferralAccount(ctx, &lark.WithdrawHireReferralAccountReq{
				ReferralAccountID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

		t.Run("", func(t *testing.T) {

			_, _, err := moduleCli.ReconcileHireReferralAccount(ctx, &lark.ReconcileHireReferralAccountReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

	})
}
