// 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_VC_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.VC

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

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

	})

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

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

			cli.Mock().MockVCApplyVCReserve(func(ctx context.Context, request *lark.ApplyVCReserveReq, options ...lark.MethodOptionFunc) (*lark.ApplyVCReserveResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCApplyVCReserve()

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

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

			cli.Mock().MockVCUpdateVCReserve(func(ctx context.Context, request *lark.UpdateVCReserveReq, options ...lark.MethodOptionFunc) (*lark.UpdateVCReserveResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCUpdateVCReserve()

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

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

			cli.Mock().MockVCDeleteVCReserve(func(ctx context.Context, request *lark.DeleteVCReserveReq, options ...lark.MethodOptionFunc) (*lark.DeleteVCReserveResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCDeleteVCReserve()

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

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

			cli.Mock().MockVCGetVCReserve(func(ctx context.Context, request *lark.GetVCReserveReq, options ...lark.MethodOptionFunc) (*lark.GetVCReserveResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCReserve()

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

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

			cli.Mock().MockVCGetVCReserveActiveMeeting(func(ctx context.Context, request *lark.GetVCReserveActiveMeetingReq, options ...lark.MethodOptionFunc) (*lark.GetVCReserveActiveMeetingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCReserveActiveMeeting()

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

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

			cli.Mock().MockVCGetVCMeeting(func(ctx context.Context, request *lark.GetVCMeetingReq, options ...lark.MethodOptionFunc) (*lark.GetVCMeetingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCMeeting()

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

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

			cli.Mock().MockVCListVCMeetingByNo(func(ctx context.Context, request *lark.ListVCMeetingByNoReq, options ...lark.MethodOptionFunc) (*lark.ListVCMeetingByNoResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCListVCMeetingByNo()

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

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

			cli.Mock().MockVCInviteVCMeeting(func(ctx context.Context, request *lark.InviteVCMeetingReq, options ...lark.MethodOptionFunc) (*lark.InviteVCMeetingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCInviteVCMeeting()

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

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

			cli.Mock().MockVCKickoutVCMeeting(func(ctx context.Context, request *lark.KickoutVCMeetingReq, options ...lark.MethodOptionFunc) (*lark.KickoutVCMeetingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCKickoutVCMeeting()

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

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

			cli.Mock().MockVCSetVCHostMeeting(func(ctx context.Context, request *lark.SetVCHostMeetingReq, options ...lark.MethodOptionFunc) (*lark.SetVCHostMeetingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCSetVCHostMeeting()

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

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

			cli.Mock().MockVCEndVCMeeting(func(ctx context.Context, request *lark.EndVCMeetingReq, options ...lark.MethodOptionFunc) (*lark.EndVCMeetingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCEndVCMeeting()

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

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

			cli.Mock().MockVCStartVCMeetingRecording(func(ctx context.Context, request *lark.StartVCMeetingRecordingReq, options ...lark.MethodOptionFunc) (*lark.StartVCMeetingRecordingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCStartVCMeetingRecording()

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

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

			cli.Mock().MockVCStopVCMeetingRecording(func(ctx context.Context, request *lark.StopVCMeetingRecordingReq, options ...lark.MethodOptionFunc) (*lark.StopVCMeetingRecordingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCStopVCMeetingRecording()

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

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

			cli.Mock().MockVCGetVCMeetingRecording(func(ctx context.Context, request *lark.GetVCMeetingRecordingReq, options ...lark.MethodOptionFunc) (*lark.GetVCMeetingRecordingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCMeetingRecording()

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

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

			cli.Mock().MockVCSetVCPermissionMeetingRecording(func(ctx context.Context, request *lark.SetVCPermissionMeetingRecordingReq, options ...lark.MethodOptionFunc) (*lark.SetVCPermissionMeetingRecordingResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCSetVCPermissionMeetingRecording()

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

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

			cli.Mock().MockVCGetVCDailyReport(func(ctx context.Context, request *lark.GetVCDailyReportReq, options ...lark.MethodOptionFunc) (*lark.GetVCDailyReportResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCDailyReport()

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

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

			cli.Mock().MockVCGetVCTopUserReport(func(ctx context.Context, request *lark.GetVCTopUserReportReq, options ...lark.MethodOptionFunc) (*lark.GetVCTopUserReportResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCTopUserReport()

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

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

			cli.Mock().MockVCGetVCRoomList(func(ctx context.Context, request *lark.GetVCRoomListReq, options ...lark.MethodOptionFunc) (*lark.GetVCRoomListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCRoomList()

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

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

			cli.Mock().MockVCGetVCRoom(func(ctx context.Context, request *lark.GetVCRoomReq, options ...lark.MethodOptionFunc) (*lark.GetVCRoomResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCRoom()

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

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

			cli.Mock().MockVCBatchGetVCRoom(func(ctx context.Context, request *lark.BatchGetVCRoomReq, options ...lark.MethodOptionFunc) (*lark.BatchGetVCRoomResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCBatchGetVCRoom()

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

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

			cli.Mock().MockVCCreateVCRoom(func(ctx context.Context, request *lark.CreateVCRoomReq, options ...lark.MethodOptionFunc) (*lark.CreateVCRoomResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCCreateVCRoom()

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

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

			cli.Mock().MockVCUpdateVCRoom(func(ctx context.Context, request *lark.UpdateVCRoomReq, options ...lark.MethodOptionFunc) (*lark.UpdateVCRoomResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCUpdateVCRoom()

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

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

			cli.Mock().MockVCDeleteVCRoom(func(ctx context.Context, request *lark.DeleteVCRoomReq, options ...lark.MethodOptionFunc) (*lark.DeleteVCRoomResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCDeleteVCRoom()

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

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

			cli.Mock().MockVCSearchVCRoom(func(ctx context.Context, request *lark.SearchVCRoomReq, options ...lark.MethodOptionFunc) (*lark.SearchVCRoomResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCSearchVCRoom()

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

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

			cli.Mock().MockVCGetVCRoomLevelList(func(ctx context.Context, request *lark.GetVCRoomLevelListReq, options ...lark.MethodOptionFunc) (*lark.GetVCRoomLevelListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCRoomLevelList()

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

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

			cli.Mock().MockVCGetVCRoomLevel(func(ctx context.Context, request *lark.GetVCRoomLevelReq, options ...lark.MethodOptionFunc) (*lark.GetVCRoomLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCRoomLevel()

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

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

			cli.Mock().MockVCBatchGetVCRoomLevel(func(ctx context.Context, request *lark.BatchGetVCRoomLevelReq, options ...lark.MethodOptionFunc) (*lark.BatchGetVCRoomLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCBatchGetVCRoomLevel()

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

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

			cli.Mock().MockVCCreateVCRoomLevel(func(ctx context.Context, request *lark.CreateVCRoomLevelReq, options ...lark.MethodOptionFunc) (*lark.CreateVCRoomLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCCreateVCRoomLevel()

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

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

			cli.Mock().MockVCUpdateVCRoomLevel(func(ctx context.Context, request *lark.UpdateVCRoomLevelReq, options ...lark.MethodOptionFunc) (*lark.UpdateVCRoomLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCUpdateVCRoomLevel()

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

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

			cli.Mock().MockVCDeleteVCRoomLevel(func(ctx context.Context, request *lark.DeleteVCRoomLevelReq, options ...lark.MethodOptionFunc) (*lark.DeleteVCRoomLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCDeleteVCRoomLevel()

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

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

			cli.Mock().MockVCSearchVCRoomLevel(func(ctx context.Context, request *lark.SearchVCRoomLevelReq, options ...lark.MethodOptionFunc) (*lark.SearchVCRoomLevelResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCSearchVCRoomLevel()

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

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

			cli.Mock().MockVCSetVCScopeConfig(func(ctx context.Context, request *lark.SetVCScopeConfigReq, options ...lark.MethodOptionFunc) (*lark.SetVCScopeConfigResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCSetVCScopeConfig()

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

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

			cli.Mock().MockVCGetVCScopeConfig(func(ctx context.Context, request *lark.GetVCScopeConfigReq, options ...lark.MethodOptionFunc) (*lark.GetVCScopeConfigResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCScopeConfig()

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

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

			cli.Mock().MockVCGetVCReserveConfig(func(ctx context.Context, request *lark.GetVCReserveConfigReq, options ...lark.MethodOptionFunc) (*lark.GetVCReserveConfigResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCReserveConfig()

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

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

			cli.Mock().MockVCUpdateVCReserveConfig(func(ctx context.Context, request *lark.UpdateVCReserveConfigReq, options ...lark.MethodOptionFunc) (*lark.UpdateVCReserveConfigResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCUpdateVCReserveConfig()

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

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

			cli.Mock().MockVCGetVCReserveConfigForm(func(ctx context.Context, request *lark.GetVCReserveConfigFormReq, options ...lark.MethodOptionFunc) (*lark.GetVCReserveConfigFormResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCReserveConfigForm()

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

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

			cli.Mock().MockVCUpdateVCReserveConfigForm(func(ctx context.Context, request *lark.UpdateVCReserveConfigFormReq, options ...lark.MethodOptionFunc) (*lark.UpdateVCReserveConfigFormResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCUpdateVCReserveConfigForm()

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

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

			cli.Mock().MockVCGetVCReserveConfigAdmin(func(ctx context.Context, request *lark.GetVCReserveConfigAdminReq, options ...lark.MethodOptionFunc) (*lark.GetVCReserveConfigAdminResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCReserveConfigAdmin()

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

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

			cli.Mock().MockVCUpdateVCReserveConfigAdmin(func(ctx context.Context, request *lark.UpdateVCReserveConfigAdminReq, options ...lark.MethodOptionFunc) (*lark.UpdateVCReserveConfigAdminResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCUpdateVCReserveConfigAdmin()

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

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

			cli.Mock().MockVCGetVCReserveConfigDisableInform(func(ctx context.Context, request *lark.GetVCReserveConfigDisableInformReq, options ...lark.MethodOptionFunc) (*lark.GetVCReserveConfigDisableInformResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCReserveConfigDisableInform()

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

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

			cli.Mock().MockVCUpdateVCReserveConfigDisableInform(func(ctx context.Context, request *lark.UpdateVCReserveConfigDisableInformReq, options ...lark.MethodOptionFunc) (*lark.UpdateVCReserveConfigDisableInformResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCUpdateVCReserveConfigDisableInform()

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

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

			cli.Mock().MockVCExportVCMeetingList(func(ctx context.Context, request *lark.ExportVCMeetingListReq, options ...lark.MethodOptionFunc) (*lark.ExportVCMeetingListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCExportVCMeetingList()

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

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

			cli.Mock().MockVCExportVCParticipantList(func(ctx context.Context, request *lark.ExportVCParticipantListReq, options ...lark.MethodOptionFunc) (*lark.ExportVCParticipantListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCExportVCParticipantList()

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

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

			cli.Mock().MockVCExportVCParticipantQualityList(func(ctx context.Context, request *lark.ExportVCParticipantQualityListReq, options ...lark.MethodOptionFunc) (*lark.ExportVCParticipantQualityListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCExportVCParticipantQualityList()

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

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

			cli.Mock().MockVCExportVCResourceReservationList(func(ctx context.Context, request *lark.ExportVCResourceReservationListReq, options ...lark.MethodOptionFunc) (*lark.ExportVCResourceReservationListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCExportVCResourceReservationList()

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

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

			cli.Mock().MockVCGetVCExportTask(func(ctx context.Context, request *lark.GetVCExportTaskReq, options ...lark.MethodOptionFunc) (*lark.GetVCExportTaskResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCExportTask()

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

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

			cli.Mock().MockVCDownloadVCExportFile(func(ctx context.Context, request *lark.DownloadVCExportFileReq, options ...lark.MethodOptionFunc) (*lark.DownloadVCExportFileResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCDownloadVCExportFile()

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

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

			cli.Mock().MockVCGetVCAlertList(func(ctx context.Context, request *lark.GetVCAlertListReq, options ...lark.MethodOptionFunc) (*lark.GetVCAlertListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCAlertList()

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

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

			cli.Mock().MockVCGetVCMeetingList(func(ctx context.Context, request *lark.GetVCMeetingListReq, options ...lark.MethodOptionFunc) (*lark.GetVCMeetingListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCMeetingList()

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

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

			cli.Mock().MockVCGetVCParticipantList(func(ctx context.Context, request *lark.GetVCParticipantListReq, options ...lark.MethodOptionFunc) (*lark.GetVCParticipantListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCParticipantList()

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

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

			cli.Mock().MockVCGetVCParticipantQualityList(func(ctx context.Context, request *lark.GetVCParticipantQualityListReq, options ...lark.MethodOptionFunc) (*lark.GetVCParticipantQualityListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCParticipantQualityList()

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

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

			cli.Mock().MockVCGetVCResourceReservationList(func(ctx context.Context, request *lark.GetVCResourceReservationListReq, options ...lark.MethodOptionFunc) (*lark.GetVCResourceReservationListResp, *lark.Response, error) {
				return nil, nil, fmt.Errorf("mock-failed")
			})
			defer cli.Mock().UnMockVCGetVCResourceReservationList()

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

	})

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

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

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

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

			_, _, err := moduleCli.UpdateVCReserve(ctx, &lark.UpdateVCReserveReq{
				ReserveID: "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.DeleteVCReserve(ctx, &lark.DeleteVCReserveReq{
				ReserveID: "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.GetVCReserve(ctx, &lark.GetVCReserveReq{
				ReserveID: "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.GetVCReserveActiveMeeting(ctx, &lark.GetVCReserveActiveMeetingReq{
				ReserveID: "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.GetVCMeeting(ctx, &lark.GetVCMeetingReq{
				MeetingID: "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.ListVCMeetingByNo(ctx, &lark.ListVCMeetingByNoReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

			_, _, err := moduleCli.InviteVCMeeting(ctx, &lark.InviteVCMeetingReq{
				MeetingID: "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.KickoutVCMeeting(ctx, &lark.KickoutVCMeetingReq{
				MeetingID: "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.SetVCHostMeeting(ctx, &lark.SetVCHostMeetingReq{
				MeetingID: "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.EndVCMeeting(ctx, &lark.EndVCMeetingReq{
				MeetingID: "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.StartVCMeetingRecording(ctx, &lark.StartVCMeetingRecordingReq{
				MeetingID: "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.StopVCMeetingRecording(ctx, &lark.StopVCMeetingRecordingReq{
				MeetingID: "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.GetVCMeetingRecording(ctx, &lark.GetVCMeetingRecordingReq{
				MeetingID: "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.SetVCPermissionMeetingRecording(ctx, &lark.SetVCPermissionMeetingRecordingReq{
				MeetingID: "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.GetVCDailyReport(ctx, &lark.GetVCDailyReportReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

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

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

			_, _, err := moduleCli.GetVCRoom(ctx, &lark.GetVCRoomReq{
				RoomID: "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.BatchGetVCRoom(ctx, &lark.BatchGetVCRoomReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

			_, _, err := moduleCli.UpdateVCRoom(ctx, &lark.UpdateVCRoomReq{
				RoomID: "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.DeleteVCRoom(ctx, &lark.DeleteVCRoomReq{
				RoomID: "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.SearchVCRoom(ctx, &lark.SearchVCRoomReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

			_, _, err := moduleCli.GetVCRoomLevel(ctx, &lark.GetVCRoomLevelReq{
				RoomLevelID: "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.BatchGetVCRoomLevel(ctx, &lark.BatchGetVCRoomLevelReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

			_, _, err := moduleCli.UpdateVCRoomLevel(ctx, &lark.UpdateVCRoomLevelReq{
				RoomLevelID: "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.DeleteVCRoomLevel(ctx, &lark.DeleteVCRoomLevelReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

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

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

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

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

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

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

			_, _, err := moduleCli.UpdateVCReserveConfig(ctx, &lark.UpdateVCReserveConfigReq{
				ReserveConfigID: "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.GetVCReserveConfigForm(ctx, &lark.GetVCReserveConfigFormReq{
				ReserveConfigID: "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.UpdateVCReserveConfigForm(ctx, &lark.UpdateVCReserveConfigFormReq{
				ReserveConfigID: "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.GetVCReserveConfigAdmin(ctx, &lark.GetVCReserveConfigAdminReq{
				ReserveConfigID: "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.UpdateVCReserveConfigAdmin(ctx, &lark.UpdateVCReserveConfigAdminReq{
				ReserveConfigID: "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.GetVCReserveConfigDisableInform(ctx, &lark.GetVCReserveConfigDisableInformReq{
				ReserveConfigID: "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.UpdateVCReserveConfigDisableInform(ctx, &lark.UpdateVCReserveConfigDisableInformReq{
				ReserveConfigID: "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.ExportVCMeetingList(ctx, &lark.ExportVCMeetingListReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.GetVCExportTask(ctx, &lark.GetVCExportTaskReq{
				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.DownloadVCExportFile(ctx, &lark.DownloadVCExportFileReq{})
			as.NotNil(err)
			as.True(lark.GetErrorCode(err) > 0, fmt.Sprintf("need get lark err, but get %s", err))
		})

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

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

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

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

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

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

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

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

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

			_, _, err := moduleCli.GetVCResourceReservationList(ctx, &lark.GetVCResourceReservationListReq{})
			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.VC
		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.ApplyVCReserve(ctx, &lark.ApplyVCReserveReq{})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateVCReserve(ctx, &lark.UpdateVCReserveReq{
				ReserveID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteVCReserve(ctx, &lark.DeleteVCReserveReq{
				ReserveID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetVCReserve(ctx, &lark.GetVCReserveReq{
				ReserveID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetVCReserveActiveMeeting(ctx, &lark.GetVCReserveActiveMeetingReq{
				ReserveID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetVCMeeting(ctx, &lark.GetVCMeetingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

			_, _, err := moduleCli.InviteVCMeeting(ctx, &lark.InviteVCMeetingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.KickoutVCMeeting(ctx, &lark.KickoutVCMeetingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SetVCHostMeeting(ctx, &lark.SetVCHostMeetingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.EndVCMeeting(ctx, &lark.EndVCMeetingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.StartVCMeetingRecording(ctx, &lark.StartVCMeetingRecordingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.StopVCMeetingRecording(ctx, &lark.StopVCMeetingRecordingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetVCMeetingRecording(ctx, &lark.GetVCMeetingRecordingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.SetVCPermissionMeetingRecording(ctx, &lark.SetVCPermissionMeetingRecordingReq{
				MeetingID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

			_, _, err := moduleCli.GetVCRoom(ctx, &lark.GetVCRoomReq{
				RoomID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.UpdateVCRoom(ctx, &lark.UpdateVCRoomReq{
				RoomID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.DeleteVCRoom(ctx, &lark.DeleteVCRoomReq{
				RoomID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.GetVCRoomLevel(ctx, &lark.GetVCRoomLevelReq{
				RoomLevelID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

			_, _, err := moduleCli.UpdateVCRoomLevel(ctx, &lark.UpdateVCRoomLevelReq{
				RoomLevelID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

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

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

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

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

			_, _, err := moduleCli.UpdateVCReserveConfig(ctx, &lark.UpdateVCReserveConfigReq{
				ReserveConfigID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetVCReserveConfigForm(ctx, &lark.GetVCReserveConfigFormReq{
				ReserveConfigID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateVCReserveConfigForm(ctx, &lark.UpdateVCReserveConfigFormReq{
				ReserveConfigID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetVCReserveConfigAdmin(ctx, &lark.GetVCReserveConfigAdminReq{
				ReserveConfigID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateVCReserveConfigAdmin(ctx, &lark.UpdateVCReserveConfigAdminReq{
				ReserveConfigID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.GetVCReserveConfigDisableInform(ctx, &lark.GetVCReserveConfigDisableInformReq{
				ReserveConfigID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

			_, _, err := moduleCli.UpdateVCReserveConfigDisableInform(ctx, &lark.UpdateVCReserveConfigDisableInformReq{
				ReserveConfigID: "x",
			})
			as.NotNil(err)
			as.Equal("fake raw request", err.Error())
		})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	})
}
