// 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_Message_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.Message

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

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

	})

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

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

			cli.Mock().MockMessageSendEphemeralMessage(func(ctx context.Context, request *lark.SendEphemeralMessageReq, options ...lark.MethodOptionFunc) (*lark.SendEphemeralMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageSendEphemeralMessage()

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

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

			cli.Mock().MockMessageSendUrgentAppMessage(func(ctx context.Context, request *lark.SendUrgentAppMessageReq, options ...lark.MethodOptionFunc) (*lark.SendUrgentAppMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageSendUrgentAppMessage()

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

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

			cli.Mock().MockMessageSendUrgentSmsMessage(func(ctx context.Context, request *lark.SendUrgentSmsMessageReq, options ...lark.MethodOptionFunc) (*lark.SendUrgentSmsMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageSendUrgentSmsMessage()

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

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

			cli.Mock().MockMessageSendUrgentPhoneMessage(func(ctx context.Context, request *lark.SendUrgentPhoneMessageReq, options ...lark.MethodOptionFunc) (*lark.SendUrgentPhoneMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageSendUrgentPhoneMessage()

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

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

			cli.Mock().MockMessageSendRawMessageOld(func(ctx context.Context, request *lark.SendRawMessageOldReq, options ...lark.MethodOptionFunc) (*lark.SendRawMessageOldResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageSendRawMessageOld()

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

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

			cli.Mock().MockMessageBatchSendOldRawMessage(func(ctx context.Context, request *lark.BatchSendOldRawMessageReq, options ...lark.MethodOptionFunc) (*lark.BatchSendOldRawMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageBatchSendOldRawMessage()

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

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

			cli.Mock().MockMessageSendRawMessage(func(ctx context.Context, request *lark.SendRawMessageReq, options ...lark.MethodOptionFunc) (*lark.SendRawMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageSendRawMessage()

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

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

			cli.Mock().MockMessageReplyRawMessage(func(ctx context.Context, request *lark.ReplyRawMessageReq, options ...lark.MethodOptionFunc) (*lark.ReplyRawMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageReplyRawMessage()

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

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

			cli.Mock().MockMessageUpdateMessageEdit(func(ctx context.Context, request *lark.UpdateMessageEditReq, options ...lark.MethodOptionFunc) (*lark.UpdateMessageEditResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageUpdateMessageEdit()

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

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

			cli.Mock().MockMessageDeleteMessage(func(ctx context.Context, request *lark.DeleteMessageReq, options ...lark.MethodOptionFunc) (*lark.DeleteMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageDeleteMessage()

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

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

			cli.Mock().MockMessageForwardMessage(func(ctx context.Context, request *lark.ForwardMessageReq, options ...lark.MethodOptionFunc) (*lark.ForwardMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageForwardMessage()

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

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

			cli.Mock().MockMessageMergeForwardMessage(func(ctx context.Context, request *lark.MergeForwardMessageReq, options ...lark.MethodOptionFunc) (*lark.MergeForwardMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageMergeForwardMessage()

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

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

			cli.Mock().MockMessageForwardThreadMessage(func(ctx context.Context, request *lark.ForwardThreadMessageReq, options ...lark.MethodOptionFunc) (*lark.ForwardThreadMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageForwardThreadMessage()

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

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

			cli.Mock().MockMessageBatchDeleteMessage(func(ctx context.Context, request *lark.BatchDeleteMessageReq, options ...lark.MethodOptionFunc) (*lark.BatchDeleteMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageBatchDeleteMessage()

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

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

			cli.Mock().MockMessageUpdateMessage(func(ctx context.Context, request *lark.UpdateMessageReq, options ...lark.MethodOptionFunc) (*lark.UpdateMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageUpdateMessage()

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

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

			cli.Mock().MockMessageUpdateMessageDelay(func(ctx context.Context, request *lark.UpdateMessageDelayReq, options ...lark.MethodOptionFunc) (*lark.UpdateMessageDelayResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageUpdateMessageDelay()

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

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

			cli.Mock().MockMessageGetMessageReadUserList(func(ctx context.Context, request *lark.GetMessageReadUserListReq, options ...lark.MethodOptionFunc) (*lark.GetMessageReadUserListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessageReadUserList()

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

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

			cli.Mock().MockMessageGetBatchSentMessageReadUser(func(ctx context.Context, request *lark.GetBatchSentMessageReadUserReq, options ...lark.MethodOptionFunc) (*lark.GetBatchSentMessageReadUserResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetBatchSentMessageReadUser()

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

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

			cli.Mock().MockMessageGetBatchSentMessageProgress(func(ctx context.Context, request *lark.GetBatchSentMessageProgressReq, options ...lark.MethodOptionFunc) (*lark.GetBatchSentMessageProgressResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetBatchSentMessageProgress()

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

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

			cli.Mock().MockMessageGetMessageList(func(ctx context.Context, request *lark.GetMessageListReq, options ...lark.MethodOptionFunc) (*lark.GetMessageListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessageList()

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

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

			cli.Mock().MockMessageGetMessageFile(func(ctx context.Context, request *lark.GetMessageFileReq, options ...lark.MethodOptionFunc) (*lark.GetMessageFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessageFile()

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

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

			cli.Mock().MockMessageGetMessage(func(ctx context.Context, request *lark.GetMessageReq, options ...lark.MethodOptionFunc) (*lark.GetMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessage()

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

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

			cli.Mock().MockMessageDeleteEphemeralMessage(func(ctx context.Context, request *lark.DeleteEphemeralMessageReq, options ...lark.MethodOptionFunc) (*lark.DeleteEphemeralMessageResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageDeleteEphemeralMessage()

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

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

			cli.Mock().MockMessageCreateMessageReaction(func(ctx context.Context, request *lark.CreateMessageReactionReq, options ...lark.MethodOptionFunc) (*lark.CreateMessageReactionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageCreateMessageReaction()

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

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

			cli.Mock().MockMessageGetMessageReactionList(func(ctx context.Context, request *lark.GetMessageReactionListReq, options ...lark.MethodOptionFunc) (*lark.GetMessageReactionListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessageReactionList()

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

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

			cli.Mock().MockMessageDeleteMessageReaction(func(ctx context.Context, request *lark.DeleteMessageReactionReq, options ...lark.MethodOptionFunc) (*lark.DeleteMessageReactionResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageDeleteMessageReaction()

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

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

			cli.Mock().MockMessageCreateMessagePin(func(ctx context.Context, request *lark.CreateMessagePinReq, options ...lark.MethodOptionFunc) (*lark.CreateMessagePinResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageCreateMessagePin()

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

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

			cli.Mock().MockMessageDeleteMessagePin(func(ctx context.Context, request *lark.DeleteMessagePinReq, options ...lark.MethodOptionFunc) (*lark.DeleteMessagePinResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageDeleteMessagePin()

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

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

			cli.Mock().MockMessageGetMessagePinList(func(ctx context.Context, request *lark.GetMessagePinListReq, options ...lark.MethodOptionFunc) (*lark.GetMessagePinListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessagePinList()

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

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

			cli.Mock().MockMessageGetMessageSpecialFocusList(func(ctx context.Context, request *lark.GetMessageSpecialFocusListReq, options ...lark.MethodOptionFunc) (*lark.GetMessageSpecialFocusListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessageSpecialFocusList()

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

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

			cli.Mock().MockMessageGetMessageSpecialFocusUnread(func(ctx context.Context, request *lark.GetMessageSpecialFocusUnreadReq, options ...lark.MethodOptionFunc) (*lark.GetMessageSpecialFocusUnreadResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageGetMessageSpecialFocusUnread()

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

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

			cli.Mock().MockMessageBatchUpdateURLPreview(func(ctx context.Context, request *lark.BatchUpdateURLPreviewReq, options ...lark.MethodOptionFunc) (*lark.BatchUpdateURLPreviewResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageBatchUpdateURLPreview()

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

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

			cli.Mock().MockMessageCreateAppFeedCard(func(ctx context.Context, request *lark.CreateAppFeedCardReq, options ...lark.MethodOptionFunc) (*lark.CreateAppFeedCardResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageCreateAppFeedCard()

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

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

			cli.Mock().MockMessageUpdateAppFeedCard(func(ctx context.Context, request *lark.UpdateAppFeedCardReq, options ...lark.MethodOptionFunc) (*lark.UpdateAppFeedCardResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageUpdateAppFeedCard()

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

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

			cli.Mock().MockMessageDeleteAppFeedCard(func(ctx context.Context, request *lark.DeleteAppFeedCardReq, options ...lark.MethodOptionFunc) (*lark.DeleteAppFeedCardResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageDeleteAppFeedCard()

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

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

			cli.Mock().MockMessageUpdateAppFeedCardButton(func(ctx context.Context, request *lark.UpdateAppFeedCardButtonReq, options ...lark.MethodOptionFunc) (*lark.UpdateAppFeedCardButtonResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageUpdateAppFeedCardButton()

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

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

			cli.Mock().MockMessageInstantReminderAppFeedCard(func(ctx context.Context, request *lark.InstantReminderAppFeedCardReq, options ...lark.MethodOptionFunc) (*lark.InstantReminderAppFeedCardResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageInstantReminderAppFeedCard()

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

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

			cli.Mock().MockMessageListIMTagRelation(func(ctx context.Context, request *lark.ListIMTagRelationReq, options ...lark.MethodOptionFunc) (*lark.ListIMTagRelationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageListIMTagRelation()

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

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

			cli.Mock().MockMessageCreateIMTag(func(ctx context.Context, request *lark.CreateIMTagReq, options ...lark.MethodOptionFunc) (*lark.CreateIMTagResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageCreateIMTag()

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

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

			cli.Mock().MockMessageUpdateIMTag(func(ctx context.Context, request *lark.UpdateIMTagReq, options ...lark.MethodOptionFunc) (*lark.UpdateIMTagResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageUpdateIMTag()

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

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

			cli.Mock().MockMessageMGetIMTag(func(ctx context.Context, request *lark.MGetIMTagReq, options ...lark.MethodOptionFunc) (*lark.MGetIMTagResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageMGetIMTag()

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

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

			cli.Mock().MockMessageCreateIMTagRelation(func(ctx context.Context, request *lark.CreateIMTagRelationReq, options ...lark.MethodOptionFunc) (*lark.CreateIMTagRelationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageCreateIMTagRelation()

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

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

			cli.Mock().MockMessageDeleteIMTagRelation(func(ctx context.Context, request *lark.DeleteIMTagRelationReq, options ...lark.MethodOptionFunc) (*lark.DeleteIMTagRelationResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockMessageDeleteIMTagRelation()

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

	})

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

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

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

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

			_, _, err := moduleCli.SendUrgentAppMessage(ctx, &lark.SendUrgentAppMessageReq{
				MessageID: "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.SendUrgentSmsMessage(ctx, &lark.SendUrgentSmsMessageReq{
				MessageID: "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.SendUrgentPhoneMessage(ctx, &lark.SendUrgentPhoneMessageReq{
				MessageID: "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.SendRawMessageOld(ctx, &lark.SendRawMessageOldReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

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

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

			_, _, err := moduleCli.ReplyRawMessage(ctx, &lark.ReplyRawMessageReq{
				MessageID: "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.UpdateMessageEdit(ctx, &lark.UpdateMessageEditReq{
				MessageID: "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.DeleteMessage(ctx, &lark.DeleteMessageReq{
				MessageID: "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.ForwardMessage(ctx, &lark.ForwardMessageReq{
				MessageID: "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.MergeForwardMessage(ctx, &lark.MergeForwardMessageReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.ForwardThreadMessage(ctx, &lark.ForwardThreadMessageReq{
				ThreadID: "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.BatchDeleteMessage(ctx, &lark.BatchDeleteMessageReq{
				BatchMessageID: "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.UpdateMessage(ctx, &lark.UpdateMessageReq{
				MessageID: "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.UpdateMessageDelay(ctx, &lark.UpdateMessageDelayReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.GetMessageReadUserList(ctx, &lark.GetMessageReadUserListReq{
				MessageID: "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.GetBatchSentMessageReadUser(ctx, &lark.GetBatchSentMessageReadUserReq{
				BatchMessageID: "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.GetBatchSentMessageProgress(ctx, &lark.GetBatchSentMessageProgressReq{
				BatchMessageID: "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.GetMessageList(ctx, &lark.GetMessageListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.GetMessageFile(ctx, &lark.GetMessageFileReq{
				MessageID: "x",
				FileKey:   "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.GetMessage(ctx, &lark.GetMessageReq{
				MessageID: "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.DeleteEphemeralMessage(ctx, &lark.DeleteEphemeralMessageReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.CreateMessageReaction(ctx, &lark.CreateMessageReactionReq{
				MessageID: "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.GetMessageReactionList(ctx, &lark.GetMessageReactionListReq{
				MessageID: "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.DeleteMessageReaction(ctx, &lark.DeleteMessageReactionReq{
				MessageID:  "x",
				ReactionID: "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.CreateMessagePin(ctx, &lark.CreateMessagePinReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.DeleteMessagePin(ctx, &lark.DeleteMessagePinReq{
				MessageID: "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.GetMessagePinList(ctx, &lark.GetMessagePinListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			_, _, err := moduleCli.InstantReminderAppFeedCard(ctx, &lark.InstantReminderAppFeedCardReq{
				FeedCardID: "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.ListIMTagRelation(ctx, &lark.ListIMTagRelationReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

			_, _, err := moduleCli.UpdateIMTag(ctx, &lark.UpdateIMTagReq{
				TagID: "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.MGetIMTag(ctx, &lark.MGetIMTagReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

			_, _, err := moduleCli.DeleteIMTagRelation(ctx, &lark.DeleteIMTagRelationReq{})
			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.Message
		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.SendEphemeralMessage(ctx, &lark.SendEphemeralMessageReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SendUrgentAppMessage(ctx, &lark.SendUrgentAppMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SendUrgentSmsMessage(ctx, &lark.SendUrgentSmsMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SendUrgentPhoneMessage(ctx, &lark.SendUrgentPhoneMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.ReplyRawMessage(ctx, &lark.ReplyRawMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateMessageEdit(ctx, &lark.UpdateMessageEditReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteMessage(ctx, &lark.DeleteMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.ForwardMessage(ctx, &lark.ForwardMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.ForwardThreadMessage(ctx, &lark.ForwardThreadMessageReq{
				ThreadID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.BatchDeleteMessage(ctx, &lark.BatchDeleteMessageReq{
				BatchMessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateMessage(ctx, &lark.UpdateMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetMessageReadUserList(ctx, &lark.GetMessageReadUserListReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetBatchSentMessageReadUser(ctx, &lark.GetBatchSentMessageReadUserReq{
				BatchMessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetBatchSentMessageProgress(ctx, &lark.GetBatchSentMessageProgressReq{
				BatchMessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.GetMessageFile(ctx, &lark.GetMessageFileReq{
				MessageID: "x",
				FileKey:   "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetMessage(ctx, &lark.GetMessageReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.CreateMessageReaction(ctx, &lark.CreateMessageReactionReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetMessageReactionList(ctx, &lark.GetMessageReactionListReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteMessageReaction(ctx, &lark.DeleteMessageReactionReq{
				MessageID:  "x",
				ReactionID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.DeleteMessagePin(ctx, &lark.DeleteMessagePinReq{
				MessageID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			_, _, err := moduleCli.InstantReminderAppFeedCard(ctx, &lark.InstantReminderAppFeedCardReq{
				FeedCardID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.UpdateIMTag(ctx, &lark.UpdateIMTagReq{
				TagID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

	})
}
