// 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_Task_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.Task

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

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

	})

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

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

			cli.Mock().MockTaskCreateTask(func(ctx context.Context, request *lark.CreateTaskReq, options ...lark.MethodOptionFunc) (*lark.CreateTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskCreateTask()

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

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

			cli.Mock().MockTaskGetTask(func(ctx context.Context, request *lark.GetTaskReq, options ...lark.MethodOptionFunc) (*lark.GetTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTask()

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

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

			cli.Mock().MockTaskUpdateTask(func(ctx context.Context, request *lark.UpdateTaskReq, options ...lark.MethodOptionFunc) (*lark.UpdateTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskUpdateTask()

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

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

			cli.Mock().MockTaskDeleteTask(func(ctx context.Context, request *lark.DeleteTaskReq, options ...lark.MethodOptionFunc) (*lark.DeleteTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskDeleteTask()

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

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

			cli.Mock().MockTaskAddTaskMember(func(ctx context.Context, request *lark.AddTaskMemberReq, options ...lark.MethodOptionFunc) (*lark.AddTaskMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskAddTaskMember()

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

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

			cli.Mock().MockTaskRemoveTaskMember(func(ctx context.Context, request *lark.RemoveTaskMemberReq, options ...lark.MethodOptionFunc) (*lark.RemoveTaskMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskRemoveTaskMember()

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

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

			cli.Mock().MockTaskGetTaskList(func(ctx context.Context, request *lark.GetTaskListReq, options ...lark.MethodOptionFunc) (*lark.GetTaskListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskList()

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

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

			cli.Mock().MockTaskAddTaskTasklist(func(ctx context.Context, request *lark.AddTaskTasklistReq, options ...lark.MethodOptionFunc) (*lark.AddTaskTasklistResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskAddTaskTasklist()

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

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

			cli.Mock().MockTaskRemoveTaskTasklist(func(ctx context.Context, request *lark.RemoveTaskTasklistReq, options ...lark.MethodOptionFunc) (*lark.RemoveTaskTasklistResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskRemoveTaskTasklist()

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

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

			cli.Mock().MockTaskAddTaskReminder(func(ctx context.Context, request *lark.AddTaskReminderReq, options ...lark.MethodOptionFunc) (*lark.AddTaskReminderResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskAddTaskReminder()

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

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

			cli.Mock().MockTaskRemoveTaskReminder(func(ctx context.Context, request *lark.RemoveTaskReminderReq, options ...lark.MethodOptionFunc) (*lark.RemoveTaskReminderResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskRemoveTaskReminder()

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

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

			cli.Mock().MockTaskAddTaskDependency(func(ctx context.Context, request *lark.AddTaskDependencyReq, options ...lark.MethodOptionFunc) (*lark.AddTaskDependencyResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskAddTaskDependency()

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

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

			cli.Mock().MockTaskRemoveTaskDependency(func(ctx context.Context, request *lark.RemoveTaskDependencyReq, options ...lark.MethodOptionFunc) (*lark.RemoveTaskDependencyResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskRemoveTaskDependency()

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

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

			cli.Mock().MockTaskCreateTaskSubtask(func(ctx context.Context, request *lark.CreateTaskSubtaskReq, options ...lark.MethodOptionFunc) (*lark.CreateTaskSubtaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskCreateTaskSubtask()

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

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

			cli.Mock().MockTaskGetTaskSubtaskList(func(ctx context.Context, request *lark.GetTaskSubtaskListReq, options ...lark.MethodOptionFunc) (*lark.GetTaskSubtaskListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskSubtaskList()

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

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

			cli.Mock().MockTaskCreateTaskTasklist(func(ctx context.Context, request *lark.CreateTaskTasklistReq, options ...lark.MethodOptionFunc) (*lark.CreateTaskTasklistResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskCreateTaskTasklist()

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

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

			cli.Mock().MockTaskGetTaskTasklist(func(ctx context.Context, request *lark.GetTaskTasklistReq, options ...lark.MethodOptionFunc) (*lark.GetTaskTasklistResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskTasklist()

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

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

			cli.Mock().MockTaskUpdateTaskTasklist(func(ctx context.Context, request *lark.UpdateTaskTasklistReq, options ...lark.MethodOptionFunc) (*lark.UpdateTaskTasklistResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskUpdateTaskTasklist()

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

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

			cli.Mock().MockTaskDeleteTaskTasklist(func(ctx context.Context, request *lark.DeleteTaskTasklistReq, options ...lark.MethodOptionFunc) (*lark.DeleteTaskTasklistResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskDeleteTaskTasklist()

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

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

			cli.Mock().MockTaskAddTaskTasklistMember(func(ctx context.Context, request *lark.AddTaskTasklistMemberReq, options ...lark.MethodOptionFunc) (*lark.AddTaskTasklistMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskAddTaskTasklistMember()

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

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

			cli.Mock().MockTaskRemoveTaskTasklistMember(func(ctx context.Context, request *lark.RemoveTaskTasklistMemberReq, options ...lark.MethodOptionFunc) (*lark.RemoveTaskTasklistMemberResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskRemoveTaskTasklistMember()

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

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

			cli.Mock().MockTaskGetTaskTaskListOfTasklist(func(ctx context.Context, request *lark.GetTaskTaskListOfTasklistReq, options ...lark.MethodOptionFunc) (*lark.GetTaskTaskListOfTasklistResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskTaskListOfTasklist()

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

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

			cli.Mock().MockTaskGetTaskTasklistList(func(ctx context.Context, request *lark.GetTaskTasklistListReq, options ...lark.MethodOptionFunc) (*lark.GetTaskTasklistListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskTasklistList()

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

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

			cli.Mock().MockTaskCreateTaskTasklistActivitySubscription(func(ctx context.Context, request *lark.CreateTaskTasklistActivitySubscriptionReq, options ...lark.MethodOptionFunc) (*lark.CreateTaskTasklistActivitySubscriptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskCreateTaskTasklistActivitySubscription()

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

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

			cli.Mock().MockTaskGetTaskTasklistActivitySubscription(func(ctx context.Context, request *lark.GetTaskTasklistActivitySubscriptionReq, options ...lark.MethodOptionFunc) (*lark.GetTaskTasklistActivitySubscriptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskTasklistActivitySubscription()

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

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

			cli.Mock().MockTaskUpdateTaskTasklistActivitySubscription(func(ctx context.Context, request *lark.UpdateTaskTasklistActivitySubscriptionReq, options ...lark.MethodOptionFunc) (*lark.UpdateTaskTasklistActivitySubscriptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskUpdateTaskTasklistActivitySubscription()

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

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

			cli.Mock().MockTaskDeleteTaskTasklistActivitySubscription(func(ctx context.Context, request *lark.DeleteTaskTasklistActivitySubscriptionReq, options ...lark.MethodOptionFunc) (*lark.DeleteTaskTasklistActivitySubscriptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskDeleteTaskTasklistActivitySubscription()

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

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

			cli.Mock().MockTaskGetTaskTasklistActivitySubscriptionList(func(ctx context.Context, request *lark.GetTaskTasklistActivitySubscriptionListReq, options ...lark.MethodOptionFunc) (*lark.GetTaskTasklistActivitySubscriptionListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskTasklistActivitySubscriptionList()

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

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

			cli.Mock().MockTaskCreateTaskComment(func(ctx context.Context, request *lark.CreateTaskCommentReq, options ...lark.MethodOptionFunc) (*lark.CreateTaskCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskCreateTaskComment()

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

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

			cli.Mock().MockTaskGetTaskComment(func(ctx context.Context, request *lark.GetTaskCommentReq, options ...lark.MethodOptionFunc) (*lark.GetTaskCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskComment()

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

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

			cli.Mock().MockTaskUpdateTaskComment(func(ctx context.Context, request *lark.UpdateTaskCommentReq, options ...lark.MethodOptionFunc) (*lark.UpdateTaskCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskUpdateTaskComment()

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

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

			cli.Mock().MockTaskDeleteTaskComment(func(ctx context.Context, request *lark.DeleteTaskCommentReq, options ...lark.MethodOptionFunc) (*lark.DeleteTaskCommentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskDeleteTaskComment()

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

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

			cli.Mock().MockTaskGetTaskCommentList(func(ctx context.Context, request *lark.GetTaskCommentListReq, options ...lark.MethodOptionFunc) (*lark.GetTaskCommentListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskCommentList()

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

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

			cli.Mock().MockTaskUploadTaskAttachment(func(ctx context.Context, request *lark.UploadTaskAttachmentReq, options ...lark.MethodOptionFunc) (*lark.UploadTaskAttachmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskUploadTaskAttachment()

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

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

			cli.Mock().MockTaskGetTaskAttachment(func(ctx context.Context, request *lark.GetTaskAttachmentReq, options ...lark.MethodOptionFunc) (*lark.GetTaskAttachmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskAttachment()

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

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

			cli.Mock().MockTaskDeleteTaskAttachment(func(ctx context.Context, request *lark.DeleteTaskAttachmentReq, options ...lark.MethodOptionFunc) (*lark.DeleteTaskAttachmentResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskDeleteTaskAttachment()

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

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

			cli.Mock().MockTaskGetTaskAttachmentList(func(ctx context.Context, request *lark.GetTaskAttachmentListReq, options ...lark.MethodOptionFunc) (*lark.GetTaskAttachmentListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskAttachmentList()

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

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

			cli.Mock().MockTaskCreateTaskSection(func(ctx context.Context, request *lark.CreateTaskSectionReq, options ...lark.MethodOptionFunc) (*lark.CreateTaskSectionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskCreateTaskSection()

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

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

			cli.Mock().MockTaskGetTaskSection(func(ctx context.Context, request *lark.GetTaskSectionReq, options ...lark.MethodOptionFunc) (*lark.GetTaskSectionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskSection()

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

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

			cli.Mock().MockTaskUpdateTaskSection(func(ctx context.Context, request *lark.UpdateTaskSectionReq, options ...lark.MethodOptionFunc) (*lark.UpdateTaskSectionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskUpdateTaskSection()

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

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

			cli.Mock().MockTaskDeleteTaskSection(func(ctx context.Context, request *lark.DeleteTaskSectionReq, options ...lark.MethodOptionFunc) (*lark.DeleteTaskSectionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskDeleteTaskSection()

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

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

			cli.Mock().MockTaskGetTaskSectionList(func(ctx context.Context, request *lark.GetTaskSectionListReq, options ...lark.MethodOptionFunc) (*lark.GetTaskSectionListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskSectionList()

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

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

			cli.Mock().MockTaskGetTaskTaskListOfSection(func(ctx context.Context, request *lark.GetTaskTaskListOfSectionReq, options ...lark.MethodOptionFunc) (*lark.GetTaskTaskListOfSectionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskGetTaskTaskListOfSection()

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

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

			cli.Mock().MockTaskAddTaskCustomField(func(ctx context.Context, request *lark.AddTaskCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.AddTaskCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskAddTaskCustomField()

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

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

			cli.Mock().MockTaskRemoveTaskCustomField(func(ctx context.Context, request *lark.RemoveTaskCustomFieldReq, options ...lark.MethodOptionFunc) (*lark.RemoveTaskCustomFieldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskRemoveTaskCustomField()

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

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

			cli.Mock().MockTaskCreateTaskCustomFieldOption(func(ctx context.Context, request *lark.CreateTaskCustomFieldOptionReq, options ...lark.MethodOptionFunc) (*lark.CreateTaskCustomFieldOptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskCreateTaskCustomFieldOption()

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

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

			cli.Mock().MockTaskUpdateTaskCustomFieldOption(func(ctx context.Context, request *lark.UpdateTaskCustomFieldOptionReq, options ...lark.MethodOptionFunc) (*lark.UpdateTaskCustomFieldOptionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockTaskUpdateTaskCustomFieldOption()

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

	})

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

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

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

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

			_, _, err := moduleCli.GetTask(ctx, &lark.GetTaskReq{
				TaskGuid: "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.UpdateTask(ctx, &lark.UpdateTaskReq{
				TaskGuid: "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.DeleteTask(ctx, &lark.DeleteTaskReq{
				TaskGuid: "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.AddTaskMember(ctx, &lark.AddTaskMemberReq{
				TaskGuid: "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.RemoveTaskMember(ctx, &lark.RemoveTaskMemberReq{
				TaskGuid: "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.GetTaskList(ctx, &lark.GetTaskListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.AddTaskTasklist(ctx, &lark.AddTaskTasklistReq{
				TaskGuid: "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.RemoveTaskTasklist(ctx, &lark.RemoveTaskTasklistReq{
				TaskGuid: "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.AddTaskReminder(ctx, &lark.AddTaskReminderReq{
				TaskGuid: "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.RemoveTaskReminder(ctx, &lark.RemoveTaskReminderReq{
				TaskGuid: "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.AddTaskDependency(ctx, &lark.AddTaskDependencyReq{
				TaskGuid: "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.RemoveTaskDependency(ctx, &lark.RemoveTaskDependencyReq{
				TaskGuid: "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.CreateTaskSubtask(ctx, &lark.CreateTaskSubtaskReq{
				TaskGuid: "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.GetTaskSubtaskList(ctx, &lark.GetTaskSubtaskListReq{
				TaskGuid: "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.CreateTaskTasklist(ctx, &lark.CreateTaskTasklistReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.GetTaskTasklist(ctx, &lark.GetTaskTasklistReq{
				TasklistGuid: "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.UpdateTaskTasklist(ctx, &lark.UpdateTaskTasklistReq{
				TasklistGuid: "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.DeleteTaskTasklist(ctx, &lark.DeleteTaskTasklistReq{
				TasklistGuid: "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.AddTaskTasklistMember(ctx, &lark.AddTaskTasklistMemberReq{
				TasklistGuid: "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.RemoveTaskTasklistMember(ctx, &lark.RemoveTaskTasklistMemberReq{
				TasklistGuid: "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.GetTaskTaskListOfTasklist(ctx, &lark.GetTaskTaskListOfTasklistReq{
				TasklistGuid: "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.GetTaskTasklistList(ctx, &lark.GetTaskTasklistListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.CreateTaskTasklistActivitySubscription(ctx, &lark.CreateTaskTasklistActivitySubscriptionReq{
				TasklistGuid: "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.GetTaskTasklistActivitySubscription(ctx, &lark.GetTaskTasklistActivitySubscriptionReq{
				TasklistGuid:             "x",
				ActivitySubscriptionGuid: "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.UpdateTaskTasklistActivitySubscription(ctx, &lark.UpdateTaskTasklistActivitySubscriptionReq{
				TasklistGuid:             "x",
				ActivitySubscriptionGuid: "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.DeleteTaskTasklistActivitySubscription(ctx, &lark.DeleteTaskTasklistActivitySubscriptionReq{
				TasklistGuid:             "x",
				ActivitySubscriptionGuid: "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.GetTaskTasklistActivitySubscriptionList(ctx, &lark.GetTaskTasklistActivitySubscriptionListReq{
				TasklistGuid: "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.CreateTaskComment(ctx, &lark.CreateTaskCommentReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.GetTaskComment(ctx, &lark.GetTaskCommentReq{
				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.UpdateTaskComment(ctx, &lark.UpdateTaskCommentReq{
				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.DeleteTaskComment(ctx, &lark.DeleteTaskCommentReq{
				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.GetTaskCommentList(ctx, &lark.GetTaskCommentListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

			_, _, err := moduleCli.GetTaskAttachment(ctx, &lark.GetTaskAttachmentReq{
				AttachmentGuid: "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.DeleteTaskAttachment(ctx, &lark.DeleteTaskAttachmentReq{
				AttachmentGuid: "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.GetTaskAttachmentList(ctx, &lark.GetTaskAttachmentListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

			_, _, err := moduleCli.GetTaskSection(ctx, &lark.GetTaskSectionReq{
				SectionGuid: "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.UpdateTaskSection(ctx, &lark.UpdateTaskSectionReq{
				SectionGuid: "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.DeleteTaskSection(ctx, &lark.DeleteTaskSectionReq{
				SectionGuid: "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.GetTaskSectionList(ctx, &lark.GetTaskSectionListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.GetTaskTaskListOfSection(ctx, &lark.GetTaskTaskListOfSectionReq{
				SectionGuid: "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.AddTaskCustomField(ctx, &lark.AddTaskCustomFieldReq{
				CustomFieldGuid: "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.RemoveTaskCustomField(ctx, &lark.RemoveTaskCustomFieldReq{
				CustomFieldGuid: "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.CreateTaskCustomFieldOption(ctx, &lark.CreateTaskCustomFieldOptionReq{
				CustomFieldGuid: "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.UpdateTaskCustomFieldOption(ctx, &lark.UpdateTaskCustomFieldOptionReq{
				CustomFieldGuid: "x",
				OptionGuid:      "x",
			})
			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.Task
		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.CreateTask(ctx, &lark.CreateTaskReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetTask(ctx, &lark.GetTaskReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateTask(ctx, &lark.UpdateTaskReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteTask(ctx, &lark.DeleteTaskReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.AddTaskMember(ctx, &lark.AddTaskMemberReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.RemoveTaskMember(ctx, &lark.RemoveTaskMemberReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.AddTaskTasklist(ctx, &lark.AddTaskTasklistReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.RemoveTaskTasklist(ctx, &lark.RemoveTaskTasklistReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.AddTaskReminder(ctx, &lark.AddTaskReminderReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.RemoveTaskReminder(ctx, &lark.RemoveTaskReminderReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.AddTaskDependency(ctx, &lark.AddTaskDependencyReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.RemoveTaskDependency(ctx, &lark.RemoveTaskDependencyReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateTaskSubtask(ctx, &lark.CreateTaskSubtaskReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetTaskSubtaskList(ctx, &lark.GetTaskSubtaskListReq{
				TaskGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetTaskTasklist(ctx, &lark.GetTaskTasklistReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateTaskTasklist(ctx, &lark.UpdateTaskTasklistReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteTaskTasklist(ctx, &lark.DeleteTaskTasklistReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.AddTaskTasklistMember(ctx, &lark.AddTaskTasklistMemberReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.RemoveTaskTasklistMember(ctx, &lark.RemoveTaskTasklistMemberReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetTaskTaskListOfTasklist(ctx, &lark.GetTaskTaskListOfTasklistReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.CreateTaskTasklistActivitySubscription(ctx, &lark.CreateTaskTasklistActivitySubscriptionReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetTaskTasklistActivitySubscription(ctx, &lark.GetTaskTasklistActivitySubscriptionReq{
				TasklistGuid:             "x",
				ActivitySubscriptionGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateTaskTasklistActivitySubscription(ctx, &lark.UpdateTaskTasklistActivitySubscriptionReq{
				TasklistGuid:             "x",
				ActivitySubscriptionGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteTaskTasklistActivitySubscription(ctx, &lark.DeleteTaskTasklistActivitySubscriptionReq{
				TasklistGuid:             "x",
				ActivitySubscriptionGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetTaskTasklistActivitySubscriptionList(ctx, &lark.GetTaskTasklistActivitySubscriptionListReq{
				TasklistGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

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

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

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

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

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

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

			_, _, err := moduleCli.GetTaskAttachment(ctx, &lark.GetTaskAttachmentReq{
				AttachmentGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteTaskAttachment(ctx, &lark.DeleteTaskAttachmentReq{
				AttachmentGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.GetTaskSection(ctx, &lark.GetTaskSectionReq{
				SectionGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateTaskSection(ctx, &lark.UpdateTaskSectionReq{
				SectionGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteTaskSection(ctx, &lark.DeleteTaskSectionReq{
				SectionGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetTaskTaskListOfSection(ctx, &lark.GetTaskTaskListOfSectionReq{
				SectionGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.AddTaskCustomField(ctx, &lark.AddTaskCustomFieldReq{
				CustomFieldGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.RemoveTaskCustomField(ctx, &lark.RemoveTaskCustomFieldReq{
				CustomFieldGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.CreateTaskCustomFieldOption(ctx, &lark.CreateTaskCustomFieldOptionReq{
				CustomFieldGuid: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateTaskCustomFieldOption(ctx, &lark.UpdateTaskCustomFieldOptionReq{
				CustomFieldGuid: "x",
				OptionGuid:      "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

	})
}
