// 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_Contact_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.Contact

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

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

	})

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

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

			cli.Mock().MockContactCreateUser(func(ctx context.Context, request *lark.CreateUserReq, options ...lark.MethodOptionFunc) (*lark.CreateUserResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateUser()

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

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

			cli.Mock().MockContactDeleteUser(func(ctx context.Context, request *lark.DeleteUserReq, options ...lark.MethodOptionFunc) (*lark.DeleteUserResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteUser()

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

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

			cli.Mock().MockContactResurrectUser(func(ctx context.Context, request *lark.ResurrectUserReq, options ...lark.MethodOptionFunc) (*lark.ResurrectUserResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactResurrectUser()

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

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

			cli.Mock().MockContactGetUser(func(ctx context.Context, request *lark.GetUserReq, options ...lark.MethodOptionFunc) (*lark.GetUserResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetUser()

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

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

			cli.Mock().MockContactBatchGetUser(func(ctx context.Context, request *lark.BatchGetUserReq, options ...lark.MethodOptionFunc) (*lark.BatchGetUserResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchGetUser()

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

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

			cli.Mock().MockContactGetUserList(func(ctx context.Context, request *lark.GetUserListReq, options ...lark.MethodOptionFunc) (*lark.GetUserListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetUserList()

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

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

			cli.Mock().MockContactGetUserListOld(func(ctx context.Context, request *lark.GetUserListOldReq, options ...lark.MethodOptionFunc) (*lark.GetUserListOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetUserListOld()

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

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

			cli.Mock().MockContactUpdateUserPatch(func(ctx context.Context, request *lark.UpdateUserPatchReq, options ...lark.MethodOptionFunc) (*lark.UpdateUserPatchResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateUserPatch()

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

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

			cli.Mock().MockContactUpdateUser(func(ctx context.Context, request *lark.UpdateUserReq, options ...lark.MethodOptionFunc) (*lark.UpdateUserResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateUser()

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

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

			cli.Mock().MockContactBatchGetUserByID(func(ctx context.Context, request *lark.BatchGetUserByIDReq, options ...lark.MethodOptionFunc) (*lark.BatchGetUserByIDResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchGetUserByID()

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

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

			cli.Mock().MockContactBatchGetUserByIDOld(func(ctx context.Context, request *lark.BatchGetUserByIDOldReq, options ...lark.MethodOptionFunc) (*lark.BatchGetUserByIDOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchGetUserByIDOld()

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

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

			cli.Mock().MockContactSearchUserOld(func(ctx context.Context, request *lark.SearchUserOldReq, options ...lark.MethodOptionFunc) (*lark.SearchUserOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactSearchUserOld()

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

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

			cli.Mock().MockContactUpdateUserID(func(ctx context.Context, request *lark.UpdateUserIDReq, options ...lark.MethodOptionFunc) (*lark.UpdateUserIDResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateUserID()

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

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

			cli.Mock().MockContactCreateDepartment(func(ctx context.Context, request *lark.CreateDepartmentReq, options ...lark.MethodOptionFunc) (*lark.CreateDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateDepartment()

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

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

			cli.Mock().MockContactGetDepartment(func(ctx context.Context, request *lark.GetDepartmentReq, options ...lark.MethodOptionFunc) (*lark.GetDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetDepartment()

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

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

			cli.Mock().MockContactBatchGetDepartment(func(ctx context.Context, request *lark.BatchGetDepartmentReq, options ...lark.MethodOptionFunc) (*lark.BatchGetDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchGetDepartment()

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

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

			cli.Mock().MockContactGetDepartmentList(func(ctx context.Context, request *lark.GetDepartmentListReq, options ...lark.MethodOptionFunc) (*lark.GetDepartmentListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetDepartmentList()

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

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

			cli.Mock().MockContactUpdateDepartmentPatch(func(ctx context.Context, request *lark.UpdateDepartmentPatchReq, options ...lark.MethodOptionFunc) (*lark.UpdateDepartmentPatchResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateDepartmentPatch()

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

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

			cli.Mock().MockContactUpdateDepartment(func(ctx context.Context, request *lark.UpdateDepartmentReq, options ...lark.MethodOptionFunc) (*lark.UpdateDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateDepartment()

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

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

			cli.Mock().MockContactGetDepartmentListOld(func(ctx context.Context, request *lark.GetDepartmentListOldReq, options ...lark.MethodOptionFunc) (*lark.GetDepartmentListOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetDepartmentListOld()

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

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

			cli.Mock().MockContactGetParentDepartment(func(ctx context.Context, request *lark.GetParentDepartmentReq, options ...lark.MethodOptionFunc) (*lark.GetParentDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetParentDepartment()

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

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

			cli.Mock().MockContactSearchDepartment(func(ctx context.Context, request *lark.SearchDepartmentReq, options ...lark.MethodOptionFunc) (*lark.SearchDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactSearchDepartment()

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

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

			cli.Mock().MockContactUpdateDepartmentID(func(ctx context.Context, request *lark.UpdateDepartmentIDReq, options ...lark.MethodOptionFunc) (*lark.UpdateDepartmentIDResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateDepartmentID()

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

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

			cli.Mock().MockContactDeleteDepartment(func(ctx context.Context, request *lark.DeleteDepartmentReq, options ...lark.MethodOptionFunc) (*lark.DeleteDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteDepartment()

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

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

			cli.Mock().MockContactUnbindDepartmentChat(func(ctx context.Context, request *lark.UnbindDepartmentChatReq, options ...lark.MethodOptionFunc) (*lark.UnbindDepartmentChatResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUnbindDepartmentChat()

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

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

			cli.Mock().MockContactCreateContactGroup(func(ctx context.Context, request *lark.CreateContactGroupReq, options ...lark.MethodOptionFunc) (*lark.CreateContactGroupResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateContactGroup()

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

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

			cli.Mock().MockContactUpdateContactGroup(func(ctx context.Context, request *lark.UpdateContactGroupReq, options ...lark.MethodOptionFunc) (*lark.UpdateContactGroupResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateContactGroup()

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

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

			cli.Mock().MockContactDeleteContactGroup(func(ctx context.Context, request *lark.DeleteContactGroupReq, options ...lark.MethodOptionFunc) (*lark.DeleteContactGroupResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteContactGroup()

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

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

			cli.Mock().MockContactGetContactGroup(func(ctx context.Context, request *lark.GetContactGroupReq, options ...lark.MethodOptionFunc) (*lark.GetContactGroupResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactGroup()

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

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

			cli.Mock().MockContactGetContactGroupList(func(ctx context.Context, request *lark.GetContactGroupListReq, options ...lark.MethodOptionFunc) (*lark.GetContactGroupListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactGroupList()

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

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

			cli.Mock().MockContactGetContactMemberGroupList(func(ctx context.Context, request *lark.GetContactMemberGroupListReq, options ...lark.MethodOptionFunc) (*lark.GetContactMemberGroupListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactMemberGroupList()

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

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

			cli.Mock().MockContactAddContactGroupMember(func(ctx context.Context, request *lark.AddContactGroupMemberReq, options ...lark.MethodOptionFunc) (*lark.AddContactGroupMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactAddContactGroupMember()

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

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

			cli.Mock().MockContactBatchAddContactGroupMember(func(ctx context.Context, request *lark.BatchAddContactGroupMemberReq, options ...lark.MethodOptionFunc) (*lark.BatchAddContactGroupMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchAddContactGroupMember()

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

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

			cli.Mock().MockContactDeleteContactGroupMember(func(ctx context.Context, request *lark.DeleteContactGroupMemberReq, options ...lark.MethodOptionFunc) (*lark.DeleteContactGroupMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteContactGroupMember()

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

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

			cli.Mock().MockContactBatchDeleteContactGroupMember(func(ctx context.Context, request *lark.BatchDeleteContactGroupMemberReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteContactGroupMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchDeleteContactGroupMember()

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

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

			cli.Mock().MockContactGetContactGroupMember(func(ctx context.Context, request *lark.GetContactGroupMemberReq, options ...lark.MethodOptionFunc) (*lark.GetContactGroupMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactGroupMember()

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

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

			cli.Mock().MockContactCreateContactFunctionalRole(func(ctx context.Context, request *lark.CreateContactFunctionalRoleReq, options ...lark.MethodOptionFunc) (*lark.CreateContactFunctionalRoleResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateContactFunctionalRole()

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

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

			cli.Mock().MockContactDeleteContactFunctionalRole(func(ctx context.Context, request *lark.DeleteContactFunctionalRoleReq, options ...lark.MethodOptionFunc) (*lark.DeleteContactFunctionalRoleResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteContactFunctionalRole()

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

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

			cli.Mock().MockContactUpdateContactFunctionalRole(func(ctx context.Context, request *lark.UpdateContactFunctionalRoleReq, options ...lark.MethodOptionFunc) (*lark.UpdateContactFunctionalRoleResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateContactFunctionalRole()

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

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

			cli.Mock().MockContactBatchCreateContactFunctionalRoleMember(func(ctx context.Context, request *lark.BatchCreateContactFunctionalRoleMemberReq, options ...lark.MethodOptionFunc) (*lark.BatchCreateContactFunctionalRoleMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchCreateContactFunctionalRoleMember()

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

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

			cli.Mock().MockContactBatchDeleteContactFunctionalRoleMember(func(ctx context.Context, request *lark.BatchDeleteContactFunctionalRoleMemberReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteContactFunctionalRoleMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBatchDeleteContactFunctionalRoleMember()

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

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

			cli.Mock().MockContactUpdateContactFunctionalRoleMemberScope(func(ctx context.Context, request *lark.UpdateContactFunctionalRoleMemberScopeReq, options ...lark.MethodOptionFunc) (*lark.UpdateContactFunctionalRoleMemberScopeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateContactFunctionalRoleMemberScope()

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

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

			cli.Mock().MockContactGetContactFunctionalRoleMemberScope(func(ctx context.Context, request *lark.GetContactFunctionalRoleMemberScopeReq, options ...lark.MethodOptionFunc) (*lark.GetContactFunctionalRoleMemberScopeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactFunctionalRoleMemberScope()

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

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

			cli.Mock().MockContactGetContactFunctionalRoleMember(func(ctx context.Context, request *lark.GetContactFunctionalRoleMemberReq, options ...lark.MethodOptionFunc) (*lark.GetContactFunctionalRoleMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactFunctionalRoleMember()

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

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

			cli.Mock().MockContactCreateContactJobLevel(func(ctx context.Context, request *lark.CreateContactJobLevelReq, options ...lark.MethodOptionFunc) (*lark.CreateContactJobLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateContactJobLevel()

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

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

			cli.Mock().MockContactDeleteContactJobLevel(func(ctx context.Context, request *lark.DeleteContactJobLevelReq, options ...lark.MethodOptionFunc) (*lark.DeleteContactJobLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteContactJobLevel()

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

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

			cli.Mock().MockContactUpdateContactJobLevel(func(ctx context.Context, request *lark.UpdateContactJobLevelReq, options ...lark.MethodOptionFunc) (*lark.UpdateContactJobLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateContactJobLevel()

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

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

			cli.Mock().MockContactGetContactJobLevel(func(ctx context.Context, request *lark.GetContactJobLevelReq, options ...lark.MethodOptionFunc) (*lark.GetContactJobLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactJobLevel()

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

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

			cli.Mock().MockContactGetContactJobLevelList(func(ctx context.Context, request *lark.GetContactJobLevelListReq, options ...lark.MethodOptionFunc) (*lark.GetContactJobLevelListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactJobLevelList()

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

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

			cli.Mock().MockContactCreateContactJobFamily(func(ctx context.Context, request *lark.CreateContactJobFamilyReq, options ...lark.MethodOptionFunc) (*lark.CreateContactJobFamilyResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateContactJobFamily()

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

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

			cli.Mock().MockContactDeleteContactJobFamily(func(ctx context.Context, request *lark.DeleteContactJobFamilyReq, options ...lark.MethodOptionFunc) (*lark.DeleteContactJobFamilyResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteContactJobFamily()

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

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

			cli.Mock().MockContactUpdateContactJobFamily(func(ctx context.Context, request *lark.UpdateContactJobFamilyReq, options ...lark.MethodOptionFunc) (*lark.UpdateContactJobFamilyResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateContactJobFamily()

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

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

			cli.Mock().MockContactGetContactJobFamily(func(ctx context.Context, request *lark.GetContactJobFamilyReq, options ...lark.MethodOptionFunc) (*lark.GetContactJobFamilyResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactJobFamily()

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

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

			cli.Mock().MockContactGetContactJobFamilyList(func(ctx context.Context, request *lark.GetContactJobFamilyListReq, options ...lark.MethodOptionFunc) (*lark.GetContactJobFamilyListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactJobFamilyList()

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

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

			cli.Mock().MockContactGetContactJobTitle(func(ctx context.Context, request *lark.GetContactJobTitleReq, options ...lark.MethodOptionFunc) (*lark.GetContactJobTitleResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactJobTitle()

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

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

			cli.Mock().MockContactGetContactJobTitleList(func(ctx context.Context, request *lark.GetContactJobTitleListReq, options ...lark.MethodOptionFunc) (*lark.GetContactJobTitleListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactJobTitleList()

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

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

			cli.Mock().MockContactGetContactWorkCity(func(ctx context.Context, request *lark.GetContactWorkCityReq, options ...lark.MethodOptionFunc) (*lark.GetContactWorkCityResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactWorkCity()

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

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

			cli.Mock().MockContactGetContactWorkCityList(func(ctx context.Context, request *lark.GetContactWorkCityListReq, options ...lark.MethodOptionFunc) (*lark.GetContactWorkCityListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactWorkCityList()

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

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

			cli.Mock().MockContactGetEmployeeTypeEnumList(func(ctx context.Context, request *lark.GetEmployeeTypeEnumListReq, options ...lark.MethodOptionFunc) (*lark.GetEmployeeTypeEnumListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetEmployeeTypeEnumList()

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

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

			cli.Mock().MockContactUpdateEmployeeTypeEnumPatch(func(ctx context.Context, request *lark.UpdateEmployeeTypeEnumPatchReq, options ...lark.MethodOptionFunc) (*lark.UpdateEmployeeTypeEnumPatchResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateEmployeeTypeEnumPatch()

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

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

			cli.Mock().MockContactDeleteEmployeeTypeEnum(func(ctx context.Context, request *lark.DeleteEmployeeTypeEnumReq, options ...lark.MethodOptionFunc) (*lark.DeleteEmployeeTypeEnumResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteEmployeeTypeEnum()

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

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

			cli.Mock().MockContactCreateEmployeeTypeEnum(func(ctx context.Context, request *lark.CreateEmployeeTypeEnumReq, options ...lark.MethodOptionFunc) (*lark.CreateEmployeeTypeEnumResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateEmployeeTypeEnum()

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

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

			cli.Mock().MockContactGetContactCustomAttrList(func(ctx context.Context, request *lark.GetContactCustomAttrListReq, options ...lark.MethodOptionFunc) (*lark.GetContactCustomAttrListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactCustomAttrList()

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

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

			cli.Mock().MockContactCreateContactUnit(func(ctx context.Context, request *lark.CreateContactUnitReq, options ...lark.MethodOptionFunc) (*lark.CreateContactUnitResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactCreateContactUnit()

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

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

			cli.Mock().MockContactUpdateContactUnit(func(ctx context.Context, request *lark.UpdateContactUnitReq, options ...lark.MethodOptionFunc) (*lark.UpdateContactUnitResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUpdateContactUnit()

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

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

			cli.Mock().MockContactDeleteContactUnit(func(ctx context.Context, request *lark.DeleteContactUnitReq, options ...lark.MethodOptionFunc) (*lark.DeleteContactUnitResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactDeleteContactUnit()

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

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

			cli.Mock().MockContactGetContactUnit(func(ctx context.Context, request *lark.GetContactUnitReq, options ...lark.MethodOptionFunc) (*lark.GetContactUnitResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactUnit()

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

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

			cli.Mock().MockContactGetContactUnitList(func(ctx context.Context, request *lark.GetContactUnitListReq, options ...lark.MethodOptionFunc) (*lark.GetContactUnitListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactUnitList()

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

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

			cli.Mock().MockContactBindContactUnitDepartment(func(ctx context.Context, request *lark.BindContactUnitDepartmentReq, options ...lark.MethodOptionFunc) (*lark.BindContactUnitDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactBindContactUnitDepartment()

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

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

			cli.Mock().MockContactUnbindContactUnitDepartment(func(ctx context.Context, request *lark.UnbindContactUnitDepartmentReq, options ...lark.MethodOptionFunc) (*lark.UnbindContactUnitDepartmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactUnbindContactUnitDepartment()

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

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

			cli.Mock().MockContactGetContactUnitDepartmentList(func(ctx context.Context, request *lark.GetContactUnitDepartmentListReq, options ...lark.MethodOptionFunc) (*lark.GetContactUnitDepartmentListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactUnitDepartmentList()

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

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

			cli.Mock().MockContactGetContactScopeList(func(ctx context.Context, request *lark.GetContactScopeListReq, options ...lark.MethodOptionFunc) (*lark.GetContactScopeListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockContactGetContactScopeList()

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

	})

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

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

			_, _, err := moduleCli.CreateUser(ctx, &lark.CreateUserReq{})
			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.DeleteUser(ctx, &lark.DeleteUserReq{
				UserID: "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.ResurrectUser(ctx, &lark.ResurrectUserReq{
				UserID: "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.GetUser(ctx, &lark.GetUserReq{
				UserID: "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.BatchGetUser(ctx, &lark.BatchGetUserReq{})
			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.GetUserList(ctx, &lark.GetUserListReq{})
			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.GetUserListOld(ctx, &lark.GetUserListOldReq{})
			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.UpdateUserPatch(ctx, &lark.UpdateUserPatchReq{
				UserID: "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.UpdateUser(ctx, &lark.UpdateUserReq{
				UserID: "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.BatchGetUserByID(ctx, &lark.BatchGetUserByIDReq{})
			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.BatchGetUserByIDOld(ctx, &lark.BatchGetUserByIDOldReq{})
			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.SearchUserOld(ctx, &lark.SearchUserOldReq{})
			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.UpdateUserID(ctx, &lark.UpdateUserIDReq{
				UserID: "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.CreateDepartment(ctx, &lark.CreateDepartmentReq{})
			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.GetDepartment(ctx, &lark.GetDepartmentReq{
				DepartmentID: "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.BatchGetDepartment(ctx, &lark.BatchGetDepartmentReq{})
			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.GetDepartmentList(ctx, &lark.GetDepartmentListReq{
				DepartmentID: "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.UpdateDepartmentPatch(ctx, &lark.UpdateDepartmentPatchReq{
				DepartmentID: "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.UpdateDepartment(ctx, &lark.UpdateDepartmentReq{
				DepartmentID: "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.GetDepartmentListOld(ctx, &lark.GetDepartmentListOldReq{})
			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.GetParentDepartment(ctx, &lark.GetParentDepartmentReq{})
			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.SearchDepartment(ctx, &lark.SearchDepartmentReq{})
			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.UpdateDepartmentID(ctx, &lark.UpdateDepartmentIDReq{
				DepartmentID: "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.DeleteDepartment(ctx, &lark.DeleteDepartmentReq{
				DepartmentID: "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.UnbindDepartmentChat(ctx, &lark.UnbindDepartmentChatReq{})
			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.CreateContactGroup(ctx, &lark.CreateContactGroupReq{})
			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.UpdateContactGroup(ctx, &lark.UpdateContactGroupReq{
				GroupID: "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.DeleteContactGroup(ctx, &lark.DeleteContactGroupReq{
				GroupID: "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.GetContactGroup(ctx, &lark.GetContactGroupReq{
				GroupID: "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.GetContactGroupList(ctx, &lark.GetContactGroupListReq{})
			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.GetContactMemberGroupList(ctx, &lark.GetContactMemberGroupListReq{})
			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.AddContactGroupMember(ctx, &lark.AddContactGroupMemberReq{
				GroupID: "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.BatchAddContactGroupMember(ctx, &lark.BatchAddContactGroupMemberReq{
				GroupID: "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.DeleteContactGroupMember(ctx, &lark.DeleteContactGroupMemberReq{
				GroupID: "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.BatchDeleteContactGroupMember(ctx, &lark.BatchDeleteContactGroupMemberReq{
				GroupID: "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.GetContactGroupMember(ctx, &lark.GetContactGroupMemberReq{
				GroupID: "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.CreateContactFunctionalRole(ctx, &lark.CreateContactFunctionalRoleReq{})
			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.DeleteContactFunctionalRole(ctx, &lark.DeleteContactFunctionalRoleReq{
				RoleID: "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.UpdateContactFunctionalRole(ctx, &lark.UpdateContactFunctionalRoleReq{
				RoleID: "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.BatchCreateContactFunctionalRoleMember(ctx, &lark.BatchCreateContactFunctionalRoleMemberReq{
				RoleID: "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.BatchDeleteContactFunctionalRoleMember(ctx, &lark.BatchDeleteContactFunctionalRoleMemberReq{
				RoleID: "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.UpdateContactFunctionalRoleMemberScope(ctx, &lark.UpdateContactFunctionalRoleMemberScopeReq{
				RoleID: "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.GetContactFunctionalRoleMemberScope(ctx, &lark.GetContactFunctionalRoleMemberScopeReq{
				RoleID:   "x",
				MemberID: "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.GetContactFunctionalRoleMember(ctx, &lark.GetContactFunctionalRoleMemberReq{
				RoleID: "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.CreateContactJobLevel(ctx, &lark.CreateContactJobLevelReq{})
			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.DeleteContactJobLevel(ctx, &lark.DeleteContactJobLevelReq{
				JobLevelID: "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.UpdateContactJobLevel(ctx, &lark.UpdateContactJobLevelReq{
				JobLevelID: "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.GetContactJobLevel(ctx, &lark.GetContactJobLevelReq{
				JobLevelID: "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.GetContactJobLevelList(ctx, &lark.GetContactJobLevelListReq{})
			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.CreateContactJobFamily(ctx, &lark.CreateContactJobFamilyReq{})
			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.DeleteContactJobFamily(ctx, &lark.DeleteContactJobFamilyReq{
				JobFamilyID: "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.UpdateContactJobFamily(ctx, &lark.UpdateContactJobFamilyReq{
				JobFamilyID: "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.GetContactJobFamily(ctx, &lark.GetContactJobFamilyReq{
				JobFamilyID: "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.GetContactJobFamilyList(ctx, &lark.GetContactJobFamilyListReq{})
			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.GetContactJobTitle(ctx, &lark.GetContactJobTitleReq{
				JobTitleID: "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.GetContactJobTitleList(ctx, &lark.GetContactJobTitleListReq{})
			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.GetContactWorkCity(ctx, &lark.GetContactWorkCityReq{
				WorkCityID: "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.GetContactWorkCityList(ctx, &lark.GetContactWorkCityListReq{})
			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.GetEmployeeTypeEnumList(ctx, &lark.GetEmployeeTypeEnumListReq{})
			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.UpdateEmployeeTypeEnumPatch(ctx, &lark.UpdateEmployeeTypeEnumPatchReq{
				EnumID: "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.DeleteEmployeeTypeEnum(ctx, &lark.DeleteEmployeeTypeEnumReq{
				EnumID: "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.CreateEmployeeTypeEnum(ctx, &lark.CreateEmployeeTypeEnumReq{})
			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.GetContactCustomAttrList(ctx, &lark.GetContactCustomAttrListReq{})
			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.CreateContactUnit(ctx, &lark.CreateContactUnitReq{})
			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.UpdateContactUnit(ctx, &lark.UpdateContactUnitReq{
				UnitID: "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.DeleteContactUnit(ctx, &lark.DeleteContactUnitReq{
				UnitID: "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.GetContactUnit(ctx, &lark.GetContactUnitReq{
				UnitID: "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.GetContactUnitList(ctx, &lark.GetContactUnitListReq{})
			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.BindContactUnitDepartment(ctx, &lark.BindContactUnitDepartmentReq{})
			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.UnbindContactUnitDepartment(ctx, &lark.UnbindContactUnitDepartmentReq{})
			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.GetContactUnitDepartmentList(ctx, &lark.GetContactUnitDepartmentListReq{})
			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.GetContactScopeList(ctx, &lark.GetContactScopeListReq{})
			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.Contact
		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.CreateUser(ctx, &lark.CreateUserReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteUser(ctx, &lark.DeleteUserReq{
				UserID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.ResurrectUser(ctx, &lark.ResurrectUserReq{
				UserID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetUser(ctx, &lark.GetUserReq{
				UserID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.UpdateUserPatch(ctx, &lark.UpdateUserPatchReq{
				UserID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateUser(ctx, &lark.UpdateUserReq{
				UserID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.UpdateUserID(ctx, &lark.UpdateUserIDReq{
				UserID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetDepartment(ctx, &lark.GetDepartmentReq{
				DepartmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetDepartmentList(ctx, &lark.GetDepartmentListReq{
				DepartmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDepartmentPatch(ctx, &lark.UpdateDepartmentPatchReq{
				DepartmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDepartment(ctx, &lark.UpdateDepartmentReq{
				DepartmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.UpdateDepartmentID(ctx, &lark.UpdateDepartmentIDReq{
				DepartmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteDepartment(ctx, &lark.DeleteDepartmentReq{
				DepartmentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.UpdateContactGroup(ctx, &lark.UpdateContactGroupReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteContactGroup(ctx, &lark.DeleteContactGroupReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetContactGroup(ctx, &lark.GetContactGroupReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.AddContactGroupMember(ctx, &lark.AddContactGroupMemberReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchAddContactGroupMember(ctx, &lark.BatchAddContactGroupMemberReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteContactGroupMember(ctx, &lark.DeleteContactGroupMemberReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchDeleteContactGroupMember(ctx, &lark.BatchDeleteContactGroupMemberReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetContactGroupMember(ctx, &lark.GetContactGroupMemberReq{
				GroupID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.DeleteContactFunctionalRole(ctx, &lark.DeleteContactFunctionalRoleReq{
				RoleID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateContactFunctionalRole(ctx, &lark.UpdateContactFunctionalRoleReq{
				RoleID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchCreateContactFunctionalRoleMember(ctx, &lark.BatchCreateContactFunctionalRoleMemberReq{
				RoleID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchDeleteContactFunctionalRoleMember(ctx, &lark.BatchDeleteContactFunctionalRoleMemberReq{
				RoleID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateContactFunctionalRoleMemberScope(ctx, &lark.UpdateContactFunctionalRoleMemberScopeReq{
				RoleID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetContactFunctionalRoleMemberScope(ctx, &lark.GetContactFunctionalRoleMemberScopeReq{
				RoleID:   "x",
				MemberID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetContactFunctionalRoleMember(ctx, &lark.GetContactFunctionalRoleMemberReq{
				RoleID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.DeleteContactJobLevel(ctx, &lark.DeleteContactJobLevelReq{
				JobLevelID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateContactJobLevel(ctx, &lark.UpdateContactJobLevelReq{
				JobLevelID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetContactJobLevel(ctx, &lark.GetContactJobLevelReq{
				JobLevelID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.DeleteContactJobFamily(ctx, &lark.DeleteContactJobFamilyReq{
				JobFamilyID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateContactJobFamily(ctx, &lark.UpdateContactJobFamilyReq{
				JobFamilyID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetContactJobFamily(ctx, &lark.GetContactJobFamilyReq{
				JobFamilyID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetContactJobTitle(ctx, &lark.GetContactJobTitleReq{
				JobTitleID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetContactWorkCity(ctx, &lark.GetContactWorkCityReq{
				WorkCityID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.UpdateEmployeeTypeEnumPatch(ctx, &lark.UpdateEmployeeTypeEnumPatchReq{
				EnumID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteEmployeeTypeEnum(ctx, &lark.DeleteEmployeeTypeEnumReq{
				EnumID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.UpdateContactUnit(ctx, &lark.UpdateContactUnitReq{
				UnitID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteContactUnit(ctx, &lark.DeleteContactUnitReq{
				UnitID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetContactUnit(ctx, &lark.GetContactUnitReq{
				UnitID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

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

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

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

	})
}
