// 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_Drive_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.Drive

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

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

	})

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

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

			cli.Mock().MockDriveGetDriveRootFolderMeta(func(ctx context.Context, request *lark.GetDriveRootFolderMetaReq, options ...lark.MethodOptionFunc) (*lark.GetDriveRootFolderMetaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveRootFolderMeta()

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

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

			cli.Mock().MockDriveGetDriveFileList(func(ctx context.Context, request *lark.GetDriveFileListReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileList()

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

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

			cli.Mock().MockDriveGetDriveFolderMeta(func(ctx context.Context, request *lark.GetDriveFolderMetaReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFolderMetaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFolderMeta()

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

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

			cli.Mock().MockDriveCreateDriveFolder(func(ctx context.Context, request *lark.CreateDriveFolderReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveFolderResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveFolder()

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

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

			cli.Mock().MockDriveGetDriveFileMeta(func(ctx context.Context, request *lark.GetDriveFileMetaReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileMetaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileMeta()

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

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

			cli.Mock().MockDriveCreateDriveFile(func(ctx context.Context, request *lark.CreateDriveFileReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveFile()

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

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

			cli.Mock().MockDriveCopyDriveFile(func(ctx context.Context, request *lark.CopyDriveFileReq, options ...lark.MethodOptionFunc) (*lark.CopyDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCopyDriveFile()

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

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

			cli.Mock().MockDriveMoveDriveFile(func(ctx context.Context, request *lark.MoveDriveFileReq, options ...lark.MethodOptionFunc) (*lark.MoveDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveMoveDriveFile()

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

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

			cli.Mock().MockDriveDeleteDriveFile(func(ctx context.Context, request *lark.DeleteDriveFileReq, options ...lark.MethodOptionFunc) (*lark.DeleteDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteDriveFile()

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

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

			cli.Mock().MockDriveGetDriveFileStatistics(func(ctx context.Context, request *lark.GetDriveFileStatisticsReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileStatisticsResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileStatistics()

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

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

			cli.Mock().MockDriveCreateDriveFileShortcut(func(ctx context.Context, request *lark.CreateDriveFileShortcutReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveFileShortcutResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveFileShortcut()

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

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

			cli.Mock().MockDriveGetDriveFileTask(func(ctx context.Context, request *lark.GetDriveFileTaskReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileTask()

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

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

			cli.Mock().MockDriveUploadDriveMedia(func(ctx context.Context, request *lark.UploadDriveMediaReq, options ...lark.MethodOptionFunc) (*lark.UploadDriveMediaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUploadDriveMedia()

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

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

			cli.Mock().MockDriveDownloadDriveMedia(func(ctx context.Context, request *lark.DownloadDriveMediaReq, options ...lark.MethodOptionFunc) (*lark.DownloadDriveMediaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDownloadDriveMedia()

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

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

			cli.Mock().MockDrivePrepareUploadDriveMedia(func(ctx context.Context, request *lark.PrepareUploadDriveMediaReq, options ...lark.MethodOptionFunc) (*lark.PrepareUploadDriveMediaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDrivePrepareUploadDriveMedia()

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

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

			cli.Mock().MockDrivePartUploadDriveMedia(func(ctx context.Context, request *lark.PartUploadDriveMediaReq, options ...lark.MethodOptionFunc) (*lark.PartUploadDriveMediaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDrivePartUploadDriveMedia()

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

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

			cli.Mock().MockDriveFinishUploadDriveMedia(func(ctx context.Context, request *lark.FinishUploadDriveMediaReq, options ...lark.MethodOptionFunc) (*lark.FinishUploadDriveMediaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveFinishUploadDriveMedia()

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

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

			cli.Mock().MockDriveGetDocxDocument(func(ctx context.Context, request *lark.GetDocxDocumentReq, options ...lark.MethodOptionFunc) (*lark.GetDocxDocumentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDocxDocument()

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

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

			cli.Mock().MockDriveGetDocxDocumentRawContent(func(ctx context.Context, request *lark.GetDocxDocumentRawContentReq, options ...lark.MethodOptionFunc) (*lark.GetDocxDocumentRawContentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDocxDocumentRawContent()

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

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

			cli.Mock().MockDriveGetDocxBlockListOfDocument(func(ctx context.Context, request *lark.GetDocxBlockListOfDocumentReq, options ...lark.MethodOptionFunc) (*lark.GetDocxBlockListOfDocumentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDocxBlockListOfDocument()

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

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

			cli.Mock().MockDriveCreateDocx(func(ctx context.Context, request *lark.CreateDocxReq, options ...lark.MethodOptionFunc) (*lark.CreateDocxResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDocx()

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

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

			cli.Mock().MockDriveGetDocxBlock(func(ctx context.Context, request *lark.GetDocxBlockReq, options ...lark.MethodOptionFunc) (*lark.GetDocxBlockResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDocxBlock()

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

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

			cli.Mock().MockDriveCreateDocxBlock(func(ctx context.Context, request *lark.CreateDocxBlockReq, options ...lark.MethodOptionFunc) (*lark.CreateDocxBlockResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDocxBlock()

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

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

			cli.Mock().MockDriveUpdateDocxBlock(func(ctx context.Context, request *lark.UpdateDocxBlockReq, options ...lark.MethodOptionFunc) (*lark.UpdateDocxBlockResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDocxBlock()

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

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

			cli.Mock().MockDriveBatchDeleteDocxBlock(func(ctx context.Context, request *lark.BatchDeleteDocxBlockReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteDocxBlockResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveBatchDeleteDocxBlock()

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

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

			cli.Mock().MockDriveGetDocxBlockListOfBlock(func(ctx context.Context, request *lark.GetDocxBlockListOfBlockReq, options ...lark.MethodOptionFunc) (*lark.GetDocxBlockListOfBlockResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDocxBlockListOfBlock()

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

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

			cli.Mock().MockDriveSubscribeDriveFile(func(ctx context.Context, request *lark.SubscribeDriveFileReq, options ...lark.MethodOptionFunc) (*lark.SubscribeDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveSubscribeDriveFile()

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

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

			cli.Mock().MockDriveUnsubscribeDriveFile(func(ctx context.Context, request *lark.UnsubscribeDriveFileReq, options ...lark.MethodOptionFunc) (*lark.UnsubscribeDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUnsubscribeDriveFile()

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

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

			cli.Mock().MockDriveGetSubscribeDriveFile(func(ctx context.Context, request *lark.GetSubscribeDriveFileReq, options ...lark.MethodOptionFunc) (*lark.GetSubscribeDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSubscribeDriveFile()

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

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

			cli.Mock().MockDriveSearchDriveFile(func(ctx context.Context, request *lark.SearchDriveFileReq, options ...lark.MethodOptionFunc) (*lark.SearchDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveSearchDriveFile()

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

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

			cli.Mock().MockDriveDeleteDriveSheetFile(func(ctx context.Context, request *lark.DeleteDriveSheetFileReq, options ...lark.MethodOptionFunc) (*lark.DeleteDriveSheetFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteDriveSheetFile()

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

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

			cli.Mock().MockDriveGetDriveFolderChildren(func(ctx context.Context, request *lark.GetDriveFolderChildrenReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFolderChildrenResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFolderChildren()

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

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

			cli.Mock().MockDriveCreateDriveExportTask(func(ctx context.Context, request *lark.CreateDriveExportTaskReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveExportTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveExportTask()

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

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

			cli.Mock().MockDriveGetDriveExportTask(func(ctx context.Context, request *lark.GetDriveExportTaskReq, options ...lark.MethodOptionFunc) (*lark.GetDriveExportTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveExportTask()

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

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

			cli.Mock().MockDriveDownloadDriveExportTask(func(ctx context.Context, request *lark.DownloadDriveExportTaskReq, options ...lark.MethodOptionFunc) (*lark.DownloadDriveExportTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDownloadDriveExportTask()

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

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

			cli.Mock().MockDriveGetDriveFileViewRecordList(func(ctx context.Context, request *lark.GetDriveFileViewRecordListReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileViewRecordListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileViewRecordList()

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

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

			cli.Mock().MockDriveCreateDriveFileVersion(func(ctx context.Context, request *lark.CreateDriveFileVersionReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveFileVersionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveFileVersion()

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

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

			cli.Mock().MockDriveDeleteDriveFileVersion(func(ctx context.Context, request *lark.DeleteDriveFileVersionReq, options ...lark.MethodOptionFunc) (*lark.DeleteDriveFileVersionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteDriveFileVersion()

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

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

			cli.Mock().MockDriveGetDriveFileVersion(func(ctx context.Context, request *lark.GetDriveFileVersionReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileVersionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileVersion()

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

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

			cli.Mock().MockDriveGetDriveFileVersionList(func(ctx context.Context, request *lark.GetDriveFileVersionListReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileVersionListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileVersionList()

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

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

			cli.Mock().MockDriveDownloadDriveFile(func(ctx context.Context, request *lark.DownloadDriveFileReq, options ...lark.MethodOptionFunc) (*lark.DownloadDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDownloadDriveFile()

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

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

			cli.Mock().MockDriveUploadDriveFile(func(ctx context.Context, request *lark.UploadDriveFileReq, options ...lark.MethodOptionFunc) (*lark.UploadDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUploadDriveFile()

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

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

			cli.Mock().MockDrivePrepareUploadDriveFile(func(ctx context.Context, request *lark.PrepareUploadDriveFileReq, options ...lark.MethodOptionFunc) (*lark.PrepareUploadDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDrivePrepareUploadDriveFile()

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

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

			cli.Mock().MockDrivePartUploadDriveFile(func(ctx context.Context, request *lark.PartUploadDriveFileReq, options ...lark.MethodOptionFunc) (*lark.PartUploadDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDrivePartUploadDriveFile()

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

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

			cli.Mock().MockDriveFinishUploadDriveFile(func(ctx context.Context, request *lark.FinishUploadDriveFileReq, options ...lark.MethodOptionFunc) (*lark.FinishUploadDriveFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveFinishUploadDriveFile()

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

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

			cli.Mock().MockDriveCreateDriveMemberPermissionOld(func(ctx context.Context, request *lark.CreateDriveMemberPermissionOldReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveMemberPermissionOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveMemberPermissionOld()

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

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

			cli.Mock().MockDriveTransferDriveOwnerPermission(func(ctx context.Context, request *lark.TransferDriveOwnerPermissionReq, options ...lark.MethodOptionFunc) (*lark.TransferDriveOwnerPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveTransferDriveOwnerPermission()

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

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

			cli.Mock().MockDriveCheckDriveMemberPermission(func(ctx context.Context, request *lark.CheckDriveMemberPermissionReq, options ...lark.MethodOptionFunc) (*lark.CheckDriveMemberPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCheckDriveMemberPermission()

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

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

			cli.Mock().MockDriveGetDriveMemberPermissionList(func(ctx context.Context, request *lark.GetDriveMemberPermissionListReq, options ...lark.MethodOptionFunc) (*lark.GetDriveMemberPermissionListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveMemberPermissionList()

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

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

			cli.Mock().MockDriveGetDriveMemberPermissionListOld(func(ctx context.Context, request *lark.GetDriveMemberPermissionListOldReq, options ...lark.MethodOptionFunc) (*lark.GetDriveMemberPermissionListOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveMemberPermissionListOld()

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

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

			cli.Mock().MockDriveCreateDriveMemberPermission(func(ctx context.Context, request *lark.CreateDriveMemberPermissionReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveMemberPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveMemberPermission()

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

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

			cli.Mock().MockDriveUpdateDriveMemberPermission(func(ctx context.Context, request *lark.UpdateDriveMemberPermissionReq, options ...lark.MethodOptionFunc) (*lark.UpdateDriveMemberPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDriveMemberPermission()

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

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

			cli.Mock().MockDriveDeleteDriveMemberPermission(func(ctx context.Context, request *lark.DeleteDriveMemberPermissionReq, options ...lark.MethodOptionFunc) (*lark.DeleteDriveMemberPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteDriveMemberPermission()

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

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

			cli.Mock().MockDriveGetDrivePublicPermissionOld(func(ctx context.Context, request *lark.GetDrivePublicPermissionOldReq, options ...lark.MethodOptionFunc) (*lark.GetDrivePublicPermissionOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDrivePublicPermissionOld()

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

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

			cli.Mock().MockDriveCreateDrivePermissionPublicPassword(func(ctx context.Context, request *lark.CreateDrivePermissionPublicPasswordReq, options ...lark.MethodOptionFunc) (*lark.CreateDrivePermissionPublicPasswordResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDrivePermissionPublicPassword()

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

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

			cli.Mock().MockDriveUpdateDrivePermissionPublicPassword(func(ctx context.Context, request *lark.UpdateDrivePermissionPublicPasswordReq, options ...lark.MethodOptionFunc) (*lark.UpdateDrivePermissionPublicPasswordResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDrivePermissionPublicPassword()

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

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

			cli.Mock().MockDriveDeleteDrivePermissionPublicPassword(func(ctx context.Context, request *lark.DeleteDrivePermissionPublicPasswordReq, options ...lark.MethodOptionFunc) (*lark.DeleteDrivePermissionPublicPasswordResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteDrivePermissionPublicPassword()

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

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

			cli.Mock().MockDriveGetDrivePublicPermission(func(ctx context.Context, request *lark.GetDrivePublicPermissionReq, options ...lark.MethodOptionFunc) (*lark.GetDrivePublicPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDrivePublicPermission()

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

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

			cli.Mock().MockDriveUpdateDrivePublicPermission(func(ctx context.Context, request *lark.UpdateDrivePublicPermissionReq, options ...lark.MethodOptionFunc) (*lark.UpdateDrivePublicPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDrivePublicPermission()

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

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

			cli.Mock().MockDriveGetDrivePublicPermissionV2(func(ctx context.Context, request *lark.GetDrivePublicPermissionV2Req, options ...lark.MethodOptionFunc) (*lark.GetDrivePublicPermissionV2Resp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDrivePublicPermissionV2()

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

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

			cli.Mock().MockDriveUpdateDrivePublicPermissionV2(func(ctx context.Context, request *lark.UpdateDrivePublicPermissionV2Req, options ...lark.MethodOptionFunc) (*lark.UpdateDrivePublicPermissionV2Resp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDrivePublicPermissionV2()

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

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

			cli.Mock().MockDriveBatchGetDriveMediaTmpDownloadURL(func(ctx context.Context, request *lark.BatchGetDriveMediaTmpDownloadURLReq, options ...lark.MethodOptionFunc) (*lark.BatchGetDriveMediaTmpDownloadURLResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveBatchGetDriveMediaTmpDownloadURL()

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

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

			cli.Mock().MockDriveGetDriveCommentList(func(ctx context.Context, request *lark.GetDriveCommentListReq, options ...lark.MethodOptionFunc) (*lark.GetDriveCommentListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveCommentList()

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

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

			cli.Mock().MockDriveCreateDriveComment(func(ctx context.Context, request *lark.CreateDriveCommentReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveComment()

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

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

			cli.Mock().MockDriveGetDriveComment(func(ctx context.Context, request *lark.GetDriveCommentReq, options ...lark.MethodOptionFunc) (*lark.GetDriveCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveComment()

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

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

			cli.Mock().MockDriveBatchGetDriveComment(func(ctx context.Context, request *lark.BatchGetDriveCommentReq, options ...lark.MethodOptionFunc) (*lark.BatchGetDriveCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveBatchGetDriveComment()

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

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

			cli.Mock().MockDriveGetDriveCommentReplyList(func(ctx context.Context, request *lark.GetDriveCommentReplyListReq, options ...lark.MethodOptionFunc) (*lark.GetDriveCommentReplyListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveCommentReplyList()

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

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

			cli.Mock().MockDriveUpdateDriveComment(func(ctx context.Context, request *lark.UpdateDriveCommentReq, options ...lark.MethodOptionFunc) (*lark.UpdateDriveCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDriveComment()

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

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

			cli.Mock().MockDriveDeleteDriveComment(func(ctx context.Context, request *lark.DeleteDriveCommentReq, options ...lark.MethodOptionFunc) (*lark.DeleteDriveCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteDriveComment()

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

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

			cli.Mock().MockDriveUpdateDriveCommentPatch(func(ctx context.Context, request *lark.UpdateDriveCommentPatchReq, options ...lark.MethodOptionFunc) (*lark.UpdateDriveCommentPatchResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDriveCommentPatch()

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

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

			cli.Mock().MockDriveGetDriveFileSubscription(func(ctx context.Context, request *lark.GetDriveFileSubscriptionReq, options ...lark.MethodOptionFunc) (*lark.GetDriveFileSubscriptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveFileSubscription()

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

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

			cli.Mock().MockDriveCreateDriveFileSubscription(func(ctx context.Context, request *lark.CreateDriveFileSubscriptionReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveFileSubscriptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveFileSubscription()

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

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

			cli.Mock().MockDriveUpdateDriveFileSubscription(func(ctx context.Context, request *lark.UpdateDriveFileSubscriptionReq, options ...lark.MethodOptionFunc) (*lark.UpdateDriveFileSubscriptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDriveFileSubscription()

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

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

			cli.Mock().MockDriveCreateDriveDoc(func(ctx context.Context, request *lark.CreateDriveDocReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveDocResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveDoc()

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

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

			cli.Mock().MockDriveGetDriveDocContent(func(ctx context.Context, request *lark.GetDriveDocContentReq, options ...lark.MethodOptionFunc) (*lark.GetDriveDocContentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveDocContent()

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

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

			cli.Mock().MockDriveUpdateDriveDocContent(func(ctx context.Context, request *lark.UpdateDriveDocContentReq, options ...lark.MethodOptionFunc) (*lark.UpdateDriveDocContentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDriveDocContent()

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

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

			cli.Mock().MockDriveGetDriveDocRawContent(func(ctx context.Context, request *lark.GetDriveDocRawContentReq, options ...lark.MethodOptionFunc) (*lark.GetDriveDocRawContentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveDocRawContent()

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

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

			cli.Mock().MockDriveGetDriveDocMeta(func(ctx context.Context, request *lark.GetDriveDocMetaReq, options ...lark.MethodOptionFunc) (*lark.GetDriveDocMetaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveDocMeta()

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

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

			cli.Mock().MockDriveGetWhiteboardNodeList(func(ctx context.Context, request *lark.GetWhiteboardNodeListReq, options ...lark.MethodOptionFunc) (*lark.GetWhiteboardNodeListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetWhiteboardNodeList()

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

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

			cli.Mock().MockDriveUpdateSpreadsheet(func(ctx context.Context, request *lark.UpdateSpreadsheetReq, options ...lark.MethodOptionFunc) (*lark.UpdateSpreadsheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSpreadsheet()

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

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

			cli.Mock().MockDriveGetSpreadsheet(func(ctx context.Context, request *lark.GetSpreadsheetReq, options ...lark.MethodOptionFunc) (*lark.GetSpreadsheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSpreadsheet()

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

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

			cli.Mock().MockDriveCreateSpreadsheet(func(ctx context.Context, request *lark.CreateSpreadsheetReq, options ...lark.MethodOptionFunc) (*lark.CreateSpreadsheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSpreadsheet()

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

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

			cli.Mock().MockDriveGetSheetMeta(func(ctx context.Context, request *lark.GetSheetMetaReq, options ...lark.MethodOptionFunc) (*lark.GetSheetMetaResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetMeta()

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

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

			cli.Mock().MockDriveUpdateSheetProperty(func(ctx context.Context, request *lark.UpdateSheetPropertyReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetPropertyResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetProperty()

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

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

			cli.Mock().MockDriveGetSheet(func(ctx context.Context, request *lark.GetSheetReq, options ...lark.MethodOptionFunc) (*lark.GetSheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheet()

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

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

			cli.Mock().MockDriveGetSheetList(func(ctx context.Context, request *lark.GetSheetListReq, options ...lark.MethodOptionFunc) (*lark.GetSheetListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetList()

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

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

			cli.Mock().MockDriveBatchUpdateSheet(func(ctx context.Context, request *lark.BatchUpdateSheetReq, options ...lark.MethodOptionFunc) (*lark.BatchUpdateSheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveBatchUpdateSheet()

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

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

			cli.Mock().MockDriveImportSheet(func(ctx context.Context, request *lark.ImportSheetReq, options ...lark.MethodOptionFunc) (*lark.ImportSheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveImportSheet()

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

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

			cli.Mock().MockDriveCreateDriveImportTask(func(ctx context.Context, request *lark.CreateDriveImportTaskReq, options ...lark.MethodOptionFunc) (*lark.CreateDriveImportTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateDriveImportTask()

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

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

			cli.Mock().MockDriveGetDriveImportTask(func(ctx context.Context, request *lark.GetDriveImportTaskReq, options ...lark.MethodOptionFunc) (*lark.GetDriveImportTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetDriveImportTask()

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

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

			cli.Mock().MockDriveMoveSheetDimension(func(ctx context.Context, request *lark.MoveSheetDimensionReq, options ...lark.MethodOptionFunc) (*lark.MoveSheetDimensionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveMoveSheetDimension()

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

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

			cli.Mock().MockDrivePrependSheetValue(func(ctx context.Context, request *lark.PrependSheetValueReq, options ...lark.MethodOptionFunc) (*lark.PrependSheetValueResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDrivePrependSheetValue()

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

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

			cli.Mock().MockDriveAppendSheetValue(func(ctx context.Context, request *lark.AppendSheetValueReq, options ...lark.MethodOptionFunc) (*lark.AppendSheetValueResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveAppendSheetValue()

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

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

			cli.Mock().MockDriveInsertSheetDimensionRange(func(ctx context.Context, request *lark.InsertSheetDimensionRangeReq, options ...lark.MethodOptionFunc) (*lark.InsertSheetDimensionRangeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveInsertSheetDimensionRange()

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

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

			cli.Mock().MockDriveAddSheetDimensionRange(func(ctx context.Context, request *lark.AddSheetDimensionRangeReq, options ...lark.MethodOptionFunc) (*lark.AddSheetDimensionRangeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveAddSheetDimensionRange()

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

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

			cli.Mock().MockDriveUpdateSheetDimensionRange(func(ctx context.Context, request *lark.UpdateSheetDimensionRangeReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetDimensionRangeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetDimensionRange()

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

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

			cli.Mock().MockDriveDeleteSheetDimensionRange(func(ctx context.Context, request *lark.DeleteSheetDimensionRangeReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetDimensionRangeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetDimensionRange()

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

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

			cli.Mock().MockDriveGetSheetValue(func(ctx context.Context, request *lark.GetSheetValueReq, options ...lark.MethodOptionFunc) (*lark.GetSheetValueResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetValue()

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

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

			cli.Mock().MockDriveBatchGetSheetValue(func(ctx context.Context, request *lark.BatchGetSheetValueReq, options ...lark.MethodOptionFunc) (*lark.BatchGetSheetValueResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveBatchGetSheetValue()

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

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

			cli.Mock().MockDriveSetSheetValue(func(ctx context.Context, request *lark.SetSheetValueReq, options ...lark.MethodOptionFunc) (*lark.SetSheetValueResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveSetSheetValue()

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

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

			cli.Mock().MockDriveBatchSetSheetValue(func(ctx context.Context, request *lark.BatchSetSheetValueReq, options ...lark.MethodOptionFunc) (*lark.BatchSetSheetValueResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveBatchSetSheetValue()

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

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

			cli.Mock().MockDriveSetSheetStyle(func(ctx context.Context, request *lark.SetSheetStyleReq, options ...lark.MethodOptionFunc) (*lark.SetSheetStyleResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveSetSheetStyle()

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

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

			cli.Mock().MockDriveBatchSetSheetStyle(func(ctx context.Context, request *lark.BatchSetSheetStyleReq, options ...lark.MethodOptionFunc) (*lark.BatchSetSheetStyleResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveBatchSetSheetStyle()

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

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

			cli.Mock().MockDriveMergeSheetCell(func(ctx context.Context, request *lark.MergeSheetCellReq, options ...lark.MethodOptionFunc) (*lark.MergeSheetCellResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveMergeSheetCell()

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

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

			cli.Mock().MockDriveUnmergeSheetCell(func(ctx context.Context, request *lark.UnmergeSheetCellReq, options ...lark.MethodOptionFunc) (*lark.UnmergeSheetCellResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUnmergeSheetCell()

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

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

			cli.Mock().MockDriveSetSheetValueImage(func(ctx context.Context, request *lark.SetSheetValueImageReq, options ...lark.MethodOptionFunc) (*lark.SetSheetValueImageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveSetSheetValueImage()

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

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

			cli.Mock().MockDriveFindSheet(func(ctx context.Context, request *lark.FindSheetReq, options ...lark.MethodOptionFunc) (*lark.FindSheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveFindSheet()

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

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

			cli.Mock().MockDriveReplaceSheet(func(ctx context.Context, request *lark.ReplaceSheetReq, options ...lark.MethodOptionFunc) (*lark.ReplaceSheetResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveReplaceSheet()

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

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

			cli.Mock().MockDriveCreateSheetConditionFormat(func(ctx context.Context, request *lark.CreateSheetConditionFormatReq, options ...lark.MethodOptionFunc) (*lark.CreateSheetConditionFormatResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSheetConditionFormat()

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

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

			cli.Mock().MockDriveGetSheetConditionFormat(func(ctx context.Context, request *lark.GetSheetConditionFormatReq, options ...lark.MethodOptionFunc) (*lark.GetSheetConditionFormatResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetConditionFormat()

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

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

			cli.Mock().MockDriveUpdateSheetConditionFormat(func(ctx context.Context, request *lark.UpdateSheetConditionFormatReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetConditionFormatResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetConditionFormat()

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

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

			cli.Mock().MockDriveDeleteSheetConditionFormat(func(ctx context.Context, request *lark.DeleteSheetConditionFormatReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetConditionFormatResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetConditionFormat()

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

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

			cli.Mock().MockDriveCreateSheetProtectedDimension(func(ctx context.Context, request *lark.CreateSheetProtectedDimensionReq, options ...lark.MethodOptionFunc) (*lark.CreateSheetProtectedDimensionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSheetProtectedDimension()

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

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

			cli.Mock().MockDriveGetSheetProtectedDimension(func(ctx context.Context, request *lark.GetSheetProtectedDimensionReq, options ...lark.MethodOptionFunc) (*lark.GetSheetProtectedDimensionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetProtectedDimension()

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

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

			cli.Mock().MockDriveUpdateSheetProtectedDimension(func(ctx context.Context, request *lark.UpdateSheetProtectedDimensionReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetProtectedDimensionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetProtectedDimension()

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

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

			cli.Mock().MockDriveDeleteSheetProtectedDimension(func(ctx context.Context, request *lark.DeleteSheetProtectedDimensionReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetProtectedDimensionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetProtectedDimension()

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

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

			cli.Mock().MockDriveCreateSheetDataValidationDropdown(func(ctx context.Context, request *lark.CreateSheetDataValidationDropdownReq, options ...lark.MethodOptionFunc) (*lark.CreateSheetDataValidationDropdownResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSheetDataValidationDropdown()

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

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

			cli.Mock().MockDriveDeleteSheetDataValidationDropdown(func(ctx context.Context, request *lark.DeleteSheetDataValidationDropdownReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetDataValidationDropdownResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetDataValidationDropdown()

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

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

			cli.Mock().MockDriveUpdateSheetDataValidationDropdown(func(ctx context.Context, request *lark.UpdateSheetDataValidationDropdownReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetDataValidationDropdownResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetDataValidationDropdown()

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

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

			cli.Mock().MockDriveGetSheetDataValidationDropdown(func(ctx context.Context, request *lark.GetSheetDataValidationDropdownReq, options ...lark.MethodOptionFunc) (*lark.GetSheetDataValidationDropdownResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetDataValidationDropdown()

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

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

			cli.Mock().MockDriveCreateSheetFilter(func(ctx context.Context, request *lark.CreateSheetFilterReq, options ...lark.MethodOptionFunc) (*lark.CreateSheetFilterResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSheetFilter()

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

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

			cli.Mock().MockDriveDeleteSheetFilter(func(ctx context.Context, request *lark.DeleteSheetFilterReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetFilterResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetFilter()

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

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

			cli.Mock().MockDriveUpdateSheetFilter(func(ctx context.Context, request *lark.UpdateSheetFilterReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetFilterResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetFilter()

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

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

			cli.Mock().MockDriveGetSheetFilter(func(ctx context.Context, request *lark.GetSheetFilterReq, options ...lark.MethodOptionFunc) (*lark.GetSheetFilterResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetFilter()

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

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

			cli.Mock().MockDriveCreateSheetFilterView(func(ctx context.Context, request *lark.CreateSheetFilterViewReq, options ...lark.MethodOptionFunc) (*lark.CreateSheetFilterViewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSheetFilterView()

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

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

			cli.Mock().MockDriveDeleteSheetFilterView(func(ctx context.Context, request *lark.DeleteSheetFilterViewReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetFilterViewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetFilterView()

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

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

			cli.Mock().MockDriveUpdateSheetFilterView(func(ctx context.Context, request *lark.UpdateSheetFilterViewReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetFilterViewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetFilterView()

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

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

			cli.Mock().MockDriveGetSheetFilterView(func(ctx context.Context, request *lark.GetSheetFilterViewReq, options ...lark.MethodOptionFunc) (*lark.GetSheetFilterViewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetFilterView()

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

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

			cli.Mock().MockDriveQuerySheetFilterView(func(ctx context.Context, request *lark.QuerySheetFilterViewReq, options ...lark.MethodOptionFunc) (*lark.QuerySheetFilterViewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveQuerySheetFilterView()

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

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

			cli.Mock().MockDriveCreateSheetFilterViewCondition(func(ctx context.Context, request *lark.CreateSheetFilterViewConditionReq, options ...lark.MethodOptionFunc) (*lark.CreateSheetFilterViewConditionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSheetFilterViewCondition()

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

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

			cli.Mock().MockDriveDeleteSheetFilterViewCondition(func(ctx context.Context, request *lark.DeleteSheetFilterViewConditionReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetFilterViewConditionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetFilterViewCondition()

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

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

			cli.Mock().MockDriveUpdateSheetFilterViewCondition(func(ctx context.Context, request *lark.UpdateSheetFilterViewConditionReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetFilterViewConditionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetFilterViewCondition()

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

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

			cli.Mock().MockDriveGetSheetFilterViewCondition(func(ctx context.Context, request *lark.GetSheetFilterViewConditionReq, options ...lark.MethodOptionFunc) (*lark.GetSheetFilterViewConditionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetFilterViewCondition()

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

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

			cli.Mock().MockDriveQuerySheetFilterViewCondition(func(ctx context.Context, request *lark.QuerySheetFilterViewConditionReq, options ...lark.MethodOptionFunc) (*lark.QuerySheetFilterViewConditionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveQuerySheetFilterViewCondition()

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

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

			cli.Mock().MockDriveCreateSheetFloatImage(func(ctx context.Context, request *lark.CreateSheetFloatImageReq, options ...lark.MethodOptionFunc) (*lark.CreateSheetFloatImageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateSheetFloatImage()

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

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

			cli.Mock().MockDriveDeleteSheetFloatImage(func(ctx context.Context, request *lark.DeleteSheetFloatImageReq, options ...lark.MethodOptionFunc) (*lark.DeleteSheetFloatImageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteSheetFloatImage()

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

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

			cli.Mock().MockDriveUpdateSheetFloatImage(func(ctx context.Context, request *lark.UpdateSheetFloatImageReq, options ...lark.MethodOptionFunc) (*lark.UpdateSheetFloatImageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateSheetFloatImage()

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

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

			cli.Mock().MockDriveGetSheetFloatImage(func(ctx context.Context, request *lark.GetSheetFloatImageReq, options ...lark.MethodOptionFunc) (*lark.GetSheetFloatImageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetSheetFloatImage()

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

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

			cli.Mock().MockDriveQuerySheetFloatImage(func(ctx context.Context, request *lark.QuerySheetFloatImageReq, options ...lark.MethodOptionFunc) (*lark.QuerySheetFloatImageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveQuerySheetFloatImage()

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

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

			cli.Mock().MockDriveCreateWikiSpace(func(ctx context.Context, request *lark.CreateWikiSpaceReq, options ...lark.MethodOptionFunc) (*lark.CreateWikiSpaceResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateWikiSpace()

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

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

			cli.Mock().MockDriveGetWikiSpaceList(func(ctx context.Context, request *lark.GetWikiSpaceListReq, options ...lark.MethodOptionFunc) (*lark.GetWikiSpaceListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetWikiSpaceList()

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

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

			cli.Mock().MockDriveGetWikiSpace(func(ctx context.Context, request *lark.GetWikiSpaceReq, options ...lark.MethodOptionFunc) (*lark.GetWikiSpaceResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetWikiSpace()

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

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

			cli.Mock().MockDriveUpdateWikiSpaceSetting(func(ctx context.Context, request *lark.UpdateWikiSpaceSettingReq, options ...lark.MethodOptionFunc) (*lark.UpdateWikiSpaceSettingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateWikiSpaceSetting()

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

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

			cli.Mock().MockDriveDeleteWikiSpaceMember(func(ctx context.Context, request *lark.DeleteWikiSpaceMemberReq, options ...lark.MethodOptionFunc) (*lark.DeleteWikiSpaceMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteWikiSpaceMember()

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

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

			cli.Mock().MockDriveAddWikiSpaceMember(func(ctx context.Context, request *lark.AddWikiSpaceMemberReq, options ...lark.MethodOptionFunc) (*lark.AddWikiSpaceMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveAddWikiSpaceMember()

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

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

			cli.Mock().MockDriveCreateWikiNode(func(ctx context.Context, request *lark.CreateWikiNodeReq, options ...lark.MethodOptionFunc) (*lark.CreateWikiNodeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCreateWikiNode()

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

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

			cli.Mock().MockDriveGetWikiNodeList(func(ctx context.Context, request *lark.GetWikiNodeListReq, options ...lark.MethodOptionFunc) (*lark.GetWikiNodeListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetWikiNodeList()

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

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

			cli.Mock().MockDriveMoveWikiNode(func(ctx context.Context, request *lark.MoveWikiNodeReq, options ...lark.MethodOptionFunc) (*lark.MoveWikiNodeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveMoveWikiNode()

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

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

			cli.Mock().MockDriveUpdateWikiNodeTitle(func(ctx context.Context, request *lark.UpdateWikiNodeTitleReq, options ...lark.MethodOptionFunc) (*lark.UpdateWikiNodeTitleResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateWikiNodeTitle()

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

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

			cli.Mock().MockDriveCopyWikiNode(func(ctx context.Context, request *lark.CopyWikiNodeReq, options ...lark.MethodOptionFunc) (*lark.CopyWikiNodeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCopyWikiNode()

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

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

			cli.Mock().MockDriveGetWikiNode(func(ctx context.Context, request *lark.GetWikiNodeReq, options ...lark.MethodOptionFunc) (*lark.GetWikiNodeResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetWikiNode()

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

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

			cli.Mock().MockDriveMoveDocsToWiki(func(ctx context.Context, request *lark.MoveDocsToWikiReq, options ...lark.MethodOptionFunc) (*lark.MoveDocsToWikiResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveMoveDocsToWiki()

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

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

			cli.Mock().MockDriveGetWikiTask(func(ctx context.Context, request *lark.GetWikiTaskReq, options ...lark.MethodOptionFunc) (*lark.GetWikiTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveGetWikiTask()

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

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

			cli.Mock().MockDriveDeleteDriveMemberPermissionOld(func(ctx context.Context, request *lark.DeleteDriveMemberPermissionOldReq, options ...lark.MethodOptionFunc) (*lark.DeleteDriveMemberPermissionOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveDeleteDriveMemberPermissionOld()

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

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

			cli.Mock().MockDriveUpdateDriveMemberPermissionOld(func(ctx context.Context, request *lark.UpdateDriveMemberPermissionOldReq, options ...lark.MethodOptionFunc) (*lark.UpdateDriveMemberPermissionOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveUpdateDriveMemberPermissionOld()

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

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

			cli.Mock().MockDriveTransferDriveMemberPermission(func(ctx context.Context, request *lark.TransferDriveMemberPermissionReq, options ...lark.MethodOptionFunc) (*lark.TransferDriveMemberPermissionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveTransferDriveMemberPermission()

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

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

			cli.Mock().MockDriveCheckDriveMemberPermissionOld(func(ctx context.Context, request *lark.CheckDriveMemberPermissionOldReq, options ...lark.MethodOptionFunc) (*lark.CheckDriveMemberPermissionOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockDriveCheckDriveMemberPermissionOld()

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

	})

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

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

			_, _, err := moduleCli.GetDriveRootFolderMeta(ctx, &lark.GetDriveRootFolderMetaReq{})
			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.GetDriveFileList(ctx, &lark.GetDriveFileListReq{})
			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.GetDriveFolderMeta(ctx, &lark.GetDriveFolderMetaReq{
				FolderToken: "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.CreateDriveFolder(ctx, &lark.CreateDriveFolderReq{})
			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.GetDriveFileMeta(ctx, &lark.GetDriveFileMetaReq{})
			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.CreateDriveFile(ctx, &lark.CreateDriveFileReq{
				FolderToken: "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.CopyDriveFile(ctx, &lark.CopyDriveFileReq{
				FileToken: "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.MoveDriveFile(ctx, &lark.MoveDriveFileReq{
				FileToken: "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.DeleteDriveFile(ctx, &lark.DeleteDriveFileReq{
				FileToken: "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.GetDriveFileStatistics(ctx, &lark.GetDriveFileStatisticsReq{
				FileToken: "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.CreateDriveFileShortcut(ctx, &lark.CreateDriveFileShortcutReq{})
			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.GetDriveFileTask(ctx, &lark.GetDriveFileTaskReq{})
			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.UploadDriveMedia(ctx, &lark.UploadDriveMediaReq{})
			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.DownloadDriveMedia(ctx, &lark.DownloadDriveMediaReq{
				FileToken: "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.PrepareUploadDriveMedia(ctx, &lark.PrepareUploadDriveMediaReq{})
			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.PartUploadDriveMedia(ctx, &lark.PartUploadDriveMediaReq{})
			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.FinishUploadDriveMedia(ctx, &lark.FinishUploadDriveMediaReq{})
			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.GetDocxDocument(ctx, &lark.GetDocxDocumentReq{
				DocumentID: "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.GetDocxDocumentRawContent(ctx, &lark.GetDocxDocumentRawContentReq{
				DocumentID: "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.GetDocxBlockListOfDocument(ctx, &lark.GetDocxBlockListOfDocumentReq{
				DocumentID: "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.CreateDocx(ctx, &lark.CreateDocxReq{})
			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.GetDocxBlock(ctx, &lark.GetDocxBlockReq{
				DocumentID: "x",
				BlockID:    "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.CreateDocxBlock(ctx, &lark.CreateDocxBlockReq{
				DocumentID: "x",
				BlockID:    "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.UpdateDocxBlock(ctx, &lark.UpdateDocxBlockReq{
				DocumentID: "x",
				BlockID:    "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.BatchDeleteDocxBlock(ctx, &lark.BatchDeleteDocxBlockReq{
				DocumentID: "x",
				BlockID:    "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.GetDocxBlockListOfBlock(ctx, &lark.GetDocxBlockListOfBlockReq{
				DocumentID: "x",
				BlockID:    "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.SubscribeDriveFile(ctx, &lark.SubscribeDriveFileReq{
				FileToken: "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.UnsubscribeDriveFile(ctx, &lark.UnsubscribeDriveFileReq{
				FileToken: "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.GetSubscribeDriveFile(ctx, &lark.GetSubscribeDriveFileReq{
				FileToken: "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.SearchDriveFile(ctx, &lark.SearchDriveFileReq{})
			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.DeleteDriveSheetFile(ctx, &lark.DeleteDriveSheetFileReq{
				SpreadSheetToken: "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.GetDriveFolderChildren(ctx, &lark.GetDriveFolderChildrenReq{
				FolderToken: "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.CreateDriveExportTask(ctx, &lark.CreateDriveExportTaskReq{})
			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.GetDriveExportTask(ctx, &lark.GetDriveExportTaskReq{
				Ticket: "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.DownloadDriveExportTask(ctx, &lark.DownloadDriveExportTaskReq{
				FileToken: "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.GetDriveFileViewRecordList(ctx, &lark.GetDriveFileViewRecordListReq{
				FileToken: "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.CreateDriveFileVersion(ctx, &lark.CreateDriveFileVersionReq{
				FileToken: "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.DeleteDriveFileVersion(ctx, &lark.DeleteDriveFileVersionReq{
				FileToken: "x",
				VersionID: "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.GetDriveFileVersion(ctx, &lark.GetDriveFileVersionReq{
				FileToken: "x",
				VersionID: "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.GetDriveFileVersionList(ctx, &lark.GetDriveFileVersionListReq{
				FileToken: "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.DownloadDriveFile(ctx, &lark.DownloadDriveFileReq{
				FileToken: "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.UploadDriveFile(ctx, &lark.UploadDriveFileReq{})
			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.PrepareUploadDriveFile(ctx, &lark.PrepareUploadDriveFileReq{})
			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.PartUploadDriveFile(ctx, &lark.PartUploadDriveFileReq{})
			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.FinishUploadDriveFile(ctx, &lark.FinishUploadDriveFileReq{})
			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.CreateDriveMemberPermissionOld(ctx, &lark.CreateDriveMemberPermissionOldReq{})
			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.TransferDriveOwnerPermission(ctx, &lark.TransferDriveOwnerPermissionReq{
				Token: "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.CheckDriveMemberPermission(ctx, &lark.CheckDriveMemberPermissionReq{
				Token: "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.GetDriveMemberPermissionList(ctx, &lark.GetDriveMemberPermissionListReq{
				Token: "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.GetDriveMemberPermissionListOld(ctx, &lark.GetDriveMemberPermissionListOldReq{})
			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.CreateDriveMemberPermission(ctx, &lark.CreateDriveMemberPermissionReq{
				Token: "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.UpdateDriveMemberPermission(ctx, &lark.UpdateDriveMemberPermissionReq{
				Token:    "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.DeleteDriveMemberPermission(ctx, &lark.DeleteDriveMemberPermissionReq{
				Token:    "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.GetDrivePublicPermissionOld(ctx, &lark.GetDrivePublicPermissionOldReq{})
			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.CreateDrivePermissionPublicPassword(ctx, &lark.CreateDrivePermissionPublicPasswordReq{
				Token: "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.UpdateDrivePermissionPublicPassword(ctx, &lark.UpdateDrivePermissionPublicPasswordReq{
				Token: "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.DeleteDrivePermissionPublicPassword(ctx, &lark.DeleteDrivePermissionPublicPasswordReq{
				Token: "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.GetDrivePublicPermission(ctx, &lark.GetDrivePublicPermissionReq{
				Token: "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.UpdateDrivePublicPermission(ctx, &lark.UpdateDrivePublicPermissionReq{
				Token: "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.GetDrivePublicPermissionV2(ctx, &lark.GetDrivePublicPermissionV2Req{
				Token: "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.UpdateDrivePublicPermissionV2(ctx, &lark.UpdateDrivePublicPermissionV2Req{
				Token: "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.BatchGetDriveMediaTmpDownloadURL(ctx, &lark.BatchGetDriveMediaTmpDownloadURLReq{})
			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.GetDriveCommentList(ctx, &lark.GetDriveCommentListReq{
				FileToken: "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.CreateDriveComment(ctx, &lark.CreateDriveCommentReq{
				FileToken: "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.GetDriveComment(ctx, &lark.GetDriveCommentReq{
				FileToken: "x",
				CommentID: "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.BatchGetDriveComment(ctx, &lark.BatchGetDriveCommentReq{
				FileToken: "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.GetDriveCommentReplyList(ctx, &lark.GetDriveCommentReplyListReq{
				FileToken: "x",
				CommentID: "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.UpdateDriveComment(ctx, &lark.UpdateDriveCommentReq{
				FileToken: "x",
				CommentID: "x",
				ReplyID:   "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.DeleteDriveComment(ctx, &lark.DeleteDriveCommentReq{
				FileToken: "x",
				CommentID: "x",
				ReplyID:   "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.UpdateDriveCommentPatch(ctx, &lark.UpdateDriveCommentPatchReq{
				FileToken: "x",
				CommentID: "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.GetDriveFileSubscription(ctx, &lark.GetDriveFileSubscriptionReq{
				FileToken:      "x",
				SubscriptionID: "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.CreateDriveFileSubscription(ctx, &lark.CreateDriveFileSubscriptionReq{
				FileToken: "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.UpdateDriveFileSubscription(ctx, &lark.UpdateDriveFileSubscriptionReq{
				FileToken:      "x",
				SubscriptionID: "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.CreateDriveDoc(ctx, &lark.CreateDriveDocReq{})
			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.GetDriveDocContent(ctx, &lark.GetDriveDocContentReq{
				DocToken: "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.UpdateDriveDocContent(ctx, &lark.UpdateDriveDocContentReq{
				DocToken: "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.GetDriveDocRawContent(ctx, &lark.GetDriveDocRawContentReq{
				DocToken: "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.GetDriveDocMeta(ctx, &lark.GetDriveDocMetaReq{
				DocToken: "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.GetWhiteboardNodeList(ctx, &lark.GetWhiteboardNodeListReq{
				WhiteboardID: "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.UpdateSpreadsheet(ctx, &lark.UpdateSpreadsheetReq{
				SpreadSheetToken: "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.GetSpreadsheet(ctx, &lark.GetSpreadsheetReq{
				SpreadSheetToken: "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.CreateSpreadsheet(ctx, &lark.CreateSpreadsheetReq{})
			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.GetSheetMeta(ctx, &lark.GetSheetMetaReq{
				SpreadSheetToken: "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.UpdateSheetProperty(ctx, &lark.UpdateSheetPropertyReq{
				SpreadSheetToken: "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.GetSheet(ctx, &lark.GetSheetReq{
				SpreadSheetToken: "x",
				SheetID:          "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.GetSheetList(ctx, &lark.GetSheetListReq{
				SpreadSheetToken: "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.BatchUpdateSheet(ctx, &lark.BatchUpdateSheetReq{
				SpreadSheetToken: "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.ImportSheet(ctx, &lark.ImportSheetReq{})
			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.CreateDriveImportTask(ctx, &lark.CreateDriveImportTaskReq{})
			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.GetDriveImportTask(ctx, &lark.GetDriveImportTaskReq{
				Ticket: "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.MoveSheetDimension(ctx, &lark.MoveSheetDimensionReq{
				SpreadSheetToken: "x",
				SheetID:          "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.PrependSheetValue(ctx, &lark.PrependSheetValueReq{
				SpreadSheetToken: "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.AppendSheetValue(ctx, &lark.AppendSheetValueReq{
				SpreadSheetToken: "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.InsertSheetDimensionRange(ctx, &lark.InsertSheetDimensionRangeReq{
				SpreadSheetToken: "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.AddSheetDimensionRange(ctx, &lark.AddSheetDimensionRangeReq{
				SpreadSheetToken: "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.UpdateSheetDimensionRange(ctx, &lark.UpdateSheetDimensionRangeReq{
				SpreadSheetToken: "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.DeleteSheetDimensionRange(ctx, &lark.DeleteSheetDimensionRangeReq{
				SpreadSheetToken: "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.GetSheetValue(ctx, &lark.GetSheetValueReq{
				SpreadSheetToken: "x",
				Range:            "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.BatchGetSheetValue(ctx, &lark.BatchGetSheetValueReq{
				SpreadSheetToken: "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.SetSheetValue(ctx, &lark.SetSheetValueReq{
				SpreadSheetToken: "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.BatchSetSheetValue(ctx, &lark.BatchSetSheetValueReq{
				SpreadSheetToken: "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.SetSheetStyle(ctx, &lark.SetSheetStyleReq{
				SpreadSheetToken: "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.BatchSetSheetStyle(ctx, &lark.BatchSetSheetStyleReq{
				SpreadSheetToken: "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.MergeSheetCell(ctx, &lark.MergeSheetCellReq{
				SpreadSheetToken: "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.UnmergeSheetCell(ctx, &lark.UnmergeSheetCellReq{
				SpreadSheetToken: "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.SetSheetValueImage(ctx, &lark.SetSheetValueImageReq{
				SpreadSheetToken: "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.FindSheet(ctx, &lark.FindSheetReq{
				SpreadSheetToken: "x",
				SheetID:          "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.ReplaceSheet(ctx, &lark.ReplaceSheetReq{
				SpreadSheetToken: "x",
				SheetID:          "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.CreateSheetConditionFormat(ctx, &lark.CreateSheetConditionFormatReq{
				SpreadSheetToken: "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.GetSheetConditionFormat(ctx, &lark.GetSheetConditionFormatReq{
				SpreadSheetToken: "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.UpdateSheetConditionFormat(ctx, &lark.UpdateSheetConditionFormatReq{
				SpreadSheetToken: "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.DeleteSheetConditionFormat(ctx, &lark.DeleteSheetConditionFormatReq{
				SpreadSheetToken: "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.CreateSheetProtectedDimension(ctx, &lark.CreateSheetProtectedDimensionReq{
				SpreadSheetToken: "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.GetSheetProtectedDimension(ctx, &lark.GetSheetProtectedDimensionReq{
				SpreadSheetToken: "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.UpdateSheetProtectedDimension(ctx, &lark.UpdateSheetProtectedDimensionReq{
				SpreadSheetToken: "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.DeleteSheetProtectedDimension(ctx, &lark.DeleteSheetProtectedDimensionReq{
				SpreadSheetToken: "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.CreateSheetDataValidationDropdown(ctx, &lark.CreateSheetDataValidationDropdownReq{
				SpreadSheetToken: "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.DeleteSheetDataValidationDropdown(ctx, &lark.DeleteSheetDataValidationDropdownReq{
				SpreadSheetToken: "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.UpdateSheetDataValidationDropdown(ctx, &lark.UpdateSheetDataValidationDropdownReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				DataValidationID: 1,
			})
			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.GetSheetDataValidationDropdown(ctx, &lark.GetSheetDataValidationDropdownReq{
				SpreadSheetToken: "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.CreateSheetFilter(ctx, &lark.CreateSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "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.DeleteSheetFilter(ctx, &lark.DeleteSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "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.UpdateSheetFilter(ctx, &lark.UpdateSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "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.GetSheetFilter(ctx, &lark.GetSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "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.CreateSheetFilterView(ctx, &lark.CreateSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "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.DeleteSheetFilterView(ctx, &lark.DeleteSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "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.UpdateSheetFilterView(ctx, &lark.UpdateSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "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.GetSheetFilterView(ctx, &lark.GetSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "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.QuerySheetFilterView(ctx, &lark.QuerySheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "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.CreateSheetFilterViewCondition(ctx, &lark.CreateSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "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.DeleteSheetFilterViewCondition(ctx, &lark.DeleteSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
				ConditionID:      "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.UpdateSheetFilterViewCondition(ctx, &lark.UpdateSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
				ConditionID:      "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.GetSheetFilterViewCondition(ctx, &lark.GetSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
				ConditionID:      "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.QuerySheetFilterViewCondition(ctx, &lark.QuerySheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "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.CreateSheetFloatImage(ctx, &lark.CreateSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "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.DeleteSheetFloatImage(ctx, &lark.DeleteSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FloatImageID:     "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.UpdateSheetFloatImage(ctx, &lark.UpdateSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FloatImageID:     "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.GetSheetFloatImage(ctx, &lark.GetSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FloatImageID:     "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.QuerySheetFloatImage(ctx, &lark.QuerySheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "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.CreateWikiSpace(ctx, &lark.CreateWikiSpaceReq{})
			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.GetWikiSpaceList(ctx, &lark.GetWikiSpaceListReq{})
			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.GetWikiSpace(ctx, &lark.GetWikiSpaceReq{
				SpaceID: "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.UpdateWikiSpaceSetting(ctx, &lark.UpdateWikiSpaceSettingReq{
				SpaceID: "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.DeleteWikiSpaceMember(ctx, &lark.DeleteWikiSpaceMemberReq{
				SpaceID:  "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.AddWikiSpaceMember(ctx, &lark.AddWikiSpaceMemberReq{
				SpaceID: "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.CreateWikiNode(ctx, &lark.CreateWikiNodeReq{
				SpaceID: "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.GetWikiNodeList(ctx, &lark.GetWikiNodeListReq{
				SpaceID: "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.MoveWikiNode(ctx, &lark.MoveWikiNodeReq{
				SpaceID:   "x",
				NodeToken: "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.UpdateWikiNodeTitle(ctx, &lark.UpdateWikiNodeTitleReq{
				SpaceID:   "x",
				NodeToken: "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.CopyWikiNode(ctx, &lark.CopyWikiNodeReq{
				SpaceID:   "x",
				NodeToken: "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.GetWikiNode(ctx, &lark.GetWikiNodeReq{})
			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.MoveDocsToWiki(ctx, &lark.MoveDocsToWikiReq{
				SpaceID: "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.GetWikiTask(ctx, &lark.GetWikiTaskReq{
				TaskID: "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.DeleteDriveMemberPermissionOld(ctx, &lark.DeleteDriveMemberPermissionOldReq{})
			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.UpdateDriveMemberPermissionOld(ctx, &lark.UpdateDriveMemberPermissionOldReq{})
			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.TransferDriveMemberPermission(ctx, &lark.TransferDriveMemberPermissionReq{})
			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.CheckDriveMemberPermissionOld(ctx, &lark.CheckDriveMemberPermissionOldReq{})
			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.Drive
		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.GetDriveRootFolderMeta(ctx, &lark.GetDriveRootFolderMetaReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetDriveFolderMeta(ctx, &lark.GetDriveFolderMetaReq{
				FolderToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.CreateDriveFile(ctx, &lark.CreateDriveFileReq{
				FolderToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CopyDriveFile(ctx, &lark.CopyDriveFileReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.MoveDriveFile(ctx, &lark.MoveDriveFileReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteDriveFile(ctx, &lark.DeleteDriveFileReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveFileStatistics(ctx, &lark.GetDriveFileStatisticsReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.DownloadDriveMedia(ctx, &lark.DownloadDriveMediaReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.GetDocxDocument(ctx, &lark.GetDocxDocumentReq{
				DocumentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDocxDocumentRawContent(ctx, &lark.GetDocxDocumentRawContentReq{
				DocumentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDocxBlockListOfDocument(ctx, &lark.GetDocxBlockListOfDocumentReq{
				DocumentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetDocxBlock(ctx, &lark.GetDocxBlockReq{
				DocumentID: "x",
				BlockID:    "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateDocxBlock(ctx, &lark.CreateDocxBlockReq{
				DocumentID: "x",
				BlockID:    "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDocxBlock(ctx, &lark.UpdateDocxBlockReq{
				DocumentID: "x",
				BlockID:    "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchDeleteDocxBlock(ctx, &lark.BatchDeleteDocxBlockReq{
				DocumentID: "x",
				BlockID:    "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDocxBlockListOfBlock(ctx, &lark.GetDocxBlockListOfBlockReq{
				DocumentID: "x",
				BlockID:    "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SubscribeDriveFile(ctx, &lark.SubscribeDriveFileReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UnsubscribeDriveFile(ctx, &lark.UnsubscribeDriveFileReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSubscribeDriveFile(ctx, &lark.GetSubscribeDriveFileReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.DeleteDriveSheetFile(ctx, &lark.DeleteDriveSheetFileReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveFolderChildren(ctx, &lark.GetDriveFolderChildrenReq{
				FolderToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetDriveExportTask(ctx, &lark.GetDriveExportTaskReq{
				Ticket: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DownloadDriveExportTask(ctx, &lark.DownloadDriveExportTaskReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveFileViewRecordList(ctx, &lark.GetDriveFileViewRecordListReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateDriveFileVersion(ctx, &lark.CreateDriveFileVersionReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteDriveFileVersion(ctx, &lark.DeleteDriveFileVersionReq{
				FileToken: "x",
				VersionID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveFileVersion(ctx, &lark.GetDriveFileVersionReq{
				FileToken: "x",
				VersionID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveFileVersionList(ctx, &lark.GetDriveFileVersionListReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DownloadDriveFile(ctx, &lark.DownloadDriveFileReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

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

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

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

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

			_, _, err := moduleCli.TransferDriveOwnerPermission(ctx, &lark.TransferDriveOwnerPermissionReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CheckDriveMemberPermission(ctx, &lark.CheckDriveMemberPermissionReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveMemberPermissionList(ctx, &lark.GetDriveMemberPermissionListReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.CreateDriveMemberPermission(ctx, &lark.CreateDriveMemberPermissionReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.CreateDrivePermissionPublicPassword(ctx, &lark.CreateDrivePermissionPublicPasswordReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDrivePermissionPublicPassword(ctx, &lark.UpdateDrivePermissionPublicPasswordReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteDrivePermissionPublicPassword(ctx, &lark.DeleteDrivePermissionPublicPasswordReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDrivePublicPermission(ctx, &lark.GetDrivePublicPermissionReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDrivePublicPermission(ctx, &lark.UpdateDrivePublicPermissionReq{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDrivePublicPermissionV2(ctx, &lark.GetDrivePublicPermissionV2Req{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDrivePublicPermissionV2(ctx, &lark.UpdateDrivePublicPermissionV2Req{
				Token: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetDriveCommentList(ctx, &lark.GetDriveCommentListReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateDriveComment(ctx, &lark.CreateDriveCommentReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveComment(ctx, &lark.GetDriveCommentReq{
				FileToken: "x",
				CommentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchGetDriveComment(ctx, &lark.BatchGetDriveCommentReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveCommentReplyList(ctx, &lark.GetDriveCommentReplyListReq{
				FileToken: "x",
				CommentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDriveComment(ctx, &lark.UpdateDriveCommentReq{
				FileToken: "x",
				CommentID: "x",
				ReplyID:   "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteDriveComment(ctx, &lark.DeleteDriveCommentReq{
				FileToken: "x",
				CommentID: "x",
				ReplyID:   "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDriveCommentPatch(ctx, &lark.UpdateDriveCommentPatchReq{
				FileToken: "x",
				CommentID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveFileSubscription(ctx, &lark.GetDriveFileSubscriptionReq{
				FileToken:      "x",
				SubscriptionID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateDriveFileSubscription(ctx, &lark.CreateDriveFileSubscriptionReq{
				FileToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDriveFileSubscription(ctx, &lark.UpdateDriveFileSubscriptionReq{
				FileToken:      "x",
				SubscriptionID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetDriveDocContent(ctx, &lark.GetDriveDocContentReq{
				DocToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateDriveDocContent(ctx, &lark.UpdateDriveDocContentReq{
				DocToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveDocRawContent(ctx, &lark.GetDriveDocRawContentReq{
				DocToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetDriveDocMeta(ctx, &lark.GetDriveDocMetaReq{
				DocToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetWhiteboardNodeList(ctx, &lark.GetWhiteboardNodeListReq{
				WhiteboardID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSpreadsheet(ctx, &lark.UpdateSpreadsheetReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSpreadsheet(ctx, &lark.GetSpreadsheetReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetSheetMeta(ctx, &lark.GetSheetMetaReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetProperty(ctx, &lark.UpdateSheetPropertyReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheet(ctx, &lark.GetSheetReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetList(ctx, &lark.GetSheetListReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchUpdateSheet(ctx, &lark.BatchUpdateSheetReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.GetDriveImportTask(ctx, &lark.GetDriveImportTaskReq{
				Ticket: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.MoveSheetDimension(ctx, &lark.MoveSheetDimensionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.PrependSheetValue(ctx, &lark.PrependSheetValueReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.AppendSheetValue(ctx, &lark.AppendSheetValueReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.InsertSheetDimensionRange(ctx, &lark.InsertSheetDimensionRangeReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.AddSheetDimensionRange(ctx, &lark.AddSheetDimensionRangeReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetDimensionRange(ctx, &lark.UpdateSheetDimensionRangeReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetDimensionRange(ctx, &lark.DeleteSheetDimensionRangeReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetValue(ctx, &lark.GetSheetValueReq{
				SpreadSheetToken: "x",
				Range:            "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchGetSheetValue(ctx, &lark.BatchGetSheetValueReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SetSheetValue(ctx, &lark.SetSheetValueReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchSetSheetValue(ctx, &lark.BatchSetSheetValueReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SetSheetStyle(ctx, &lark.SetSheetStyleReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchSetSheetStyle(ctx, &lark.BatchSetSheetStyleReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.MergeSheetCell(ctx, &lark.MergeSheetCellReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UnmergeSheetCell(ctx, &lark.UnmergeSheetCellReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SetSheetValueImage(ctx, &lark.SetSheetValueImageReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.FindSheet(ctx, &lark.FindSheetReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.ReplaceSheet(ctx, &lark.ReplaceSheetReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateSheetConditionFormat(ctx, &lark.CreateSheetConditionFormatReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetConditionFormat(ctx, &lark.GetSheetConditionFormatReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetConditionFormat(ctx, &lark.UpdateSheetConditionFormatReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetConditionFormat(ctx, &lark.DeleteSheetConditionFormatReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateSheetProtectedDimension(ctx, &lark.CreateSheetProtectedDimensionReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetProtectedDimension(ctx, &lark.GetSheetProtectedDimensionReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetProtectedDimension(ctx, &lark.UpdateSheetProtectedDimensionReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetProtectedDimension(ctx, &lark.DeleteSheetProtectedDimensionReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateSheetDataValidationDropdown(ctx, &lark.CreateSheetDataValidationDropdownReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetDataValidationDropdown(ctx, &lark.DeleteSheetDataValidationDropdownReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetDataValidationDropdown(ctx, &lark.UpdateSheetDataValidationDropdownReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				DataValidationID: 1,
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetDataValidationDropdown(ctx, &lark.GetSheetDataValidationDropdownReq{
				SpreadSheetToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateSheetFilter(ctx, &lark.CreateSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetFilter(ctx, &lark.DeleteSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetFilter(ctx, &lark.UpdateSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetFilter(ctx, &lark.GetSheetFilterReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateSheetFilterView(ctx, &lark.CreateSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetFilterView(ctx, &lark.DeleteSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetFilterView(ctx, &lark.UpdateSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetFilterView(ctx, &lark.GetSheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.QuerySheetFilterView(ctx, &lark.QuerySheetFilterViewReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateSheetFilterViewCondition(ctx, &lark.CreateSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetFilterViewCondition(ctx, &lark.DeleteSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
				ConditionID:      "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetFilterViewCondition(ctx, &lark.UpdateSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
				ConditionID:      "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetFilterViewCondition(ctx, &lark.GetSheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
				ConditionID:      "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.QuerySheetFilterViewCondition(ctx, &lark.QuerySheetFilterViewConditionReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FilterViewID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateSheetFloatImage(ctx, &lark.CreateSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteSheetFloatImage(ctx, &lark.DeleteSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FloatImageID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateSheetFloatImage(ctx, &lark.UpdateSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FloatImageID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetSheetFloatImage(ctx, &lark.GetSheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
				FloatImageID:     "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.QuerySheetFloatImage(ctx, &lark.QuerySheetFloatImageReq{
				SpreadSheetToken: "x",
				SheetID:          "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.GetWikiSpace(ctx, &lark.GetWikiSpaceReq{
				SpaceID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateWikiSpaceSetting(ctx, &lark.UpdateWikiSpaceSettingReq{
				SpaceID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.AddWikiSpaceMember(ctx, &lark.AddWikiSpaceMemberReq{
				SpaceID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateWikiNode(ctx, &lark.CreateWikiNodeReq{
				SpaceID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetWikiNodeList(ctx, &lark.GetWikiNodeListReq{
				SpaceID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.MoveWikiNode(ctx, &lark.MoveWikiNodeReq{
				SpaceID:   "x",
				NodeToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateWikiNodeTitle(ctx, &lark.UpdateWikiNodeTitleReq{
				SpaceID:   "x",
				NodeToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CopyWikiNode(ctx, &lark.CopyWikiNodeReq{
				SpaceID:   "x",
				NodeToken: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.MoveDocsToWiki(ctx, &lark.MoveDocsToWikiReq{
				SpaceID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetWikiTask(ctx, &lark.GetWikiTaskReq{
				TaskID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

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

	})
}
