foodie-server/ruoyi-admin/src/test/java/com/ruoyi/app/pay/StallBankCardControllerTest.java

package com.ruoyi.app.pay;

import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.common.utils.DictUtils;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.app.pay.dto.BankCardSaveDto;
import com.ruoyi.system.domain.InfoBankCard;
import com.ruoyi.system.domain.InfoUser;
import com.ruoyi.system.mapper.InfoBankCardMapper;
import com.ruoyi.system.mapper.InfoUserMapper;
import com.ruoyi.system.mapper.PosStoreMapper;
import com.ruoyi.system.service.MerchantStoreAccessService;
import com.ruoyi.system.service.StallPaymentAccessService;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.support.StaticMessageSource;
import org.springframework.test.util.ReflectionTestUtils;

import java.util.Locale;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import org.mockito.ArgumentCaptor;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class StallBankCardControllerTest {
    private static ConfigurableListableBeanFactory originalBeanFactory;
    private InfoBankCardMapper cardMapper;
    private InfoUserMapper userMapper;
    private StallPaymentAccessService stallAccess;
    private PosStoreMapper storeMapper;
    private BankCardController controller;

    @BeforeAll
    static void messages() {
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), InfoBankCard.class);
        originalBeanFactory = (ConfigurableListableBeanFactory)
                ReflectionTestUtils.getField(SpringUtils.class, "beanFactory");
        DefaultListableBeanFactory beans = new DefaultListableBeanFactory();
        StaticMessageSource messages = new StaticMessageSource();
        messages.addMessage("no.user.stop", Locale.getDefault(), "无权限");
        messages.addMessage("no.action.success", Locale.getDefault(), "成功");
        beans.registerSingleton("messageSource", messages);
        new SpringUtils().postProcessBeanFactory(beans);
    }

    @AfterAll
    static void restore() {
        new SpringUtils().postProcessBeanFactory(originalBeanFactory);
    }

    @BeforeEach
    void setUp() {
        cardMapper = mock(InfoBankCardMapper.class);
        userMapper = mock(InfoUserMapper.class);
        stallAccess = mock(StallPaymentAccessService.class);
        storeMapper = mock(PosStoreMapper.class);
        controller = new BankCardController(cardMapper, userMapper,
                mock(MerchantStoreAccessService.class), stallAccess, storeMapper);
        InfoUser owner = new InfoUser();
        owner.setUserType("4");
        when(userMapper.selectById(101L)).thenReturn(owner);
        when(stallAccess.resolveStoreId(101L)).thenReturn(11L);
    }

    @Test
    void stallOwnerCannotDeleteAnotherStallsCard() {
        InfoBankCard other = new InfoBankCard();
        other.setId(7L);
        other.setStoreId(12L);
        when(cardMapper.selectById(7L)).thenReturn(other);

        assertThrows(ServiceException.class, () ->
                controller.delete(com.ruoyi.system.utils.JwtUtil.setToken("101", "test"), 7L));
        verify(cardMapper, never()).deleteById(7L);
    }

    @Test
    void stallCardListIsScopedByStoreId() {
        when(cardMapper.selectList(any())).thenReturn(java.util.List.of());

        controller.list(com.ruoyi.system.utils.JwtUtil.setToken("101", "test"));

        @SuppressWarnings("rawtypes")
        ArgumentCaptor<com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper> query =
                ArgumentCaptor.forClass(com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper.class);
        verify(cardMapper).selectList(query.capture());
        assertTrue(query.getValue().getSqlSegment().contains("store_id"));
    }

    @Test
    void activatingStallCardLocksStallBeforeChangingActiveCards() {
        InfoBankCard card = new InfoBankCard();
        card.setId(7L);
        card.setStoreId(11L);
        when(cardMapper.selectById(7L)).thenReturn(card);
        when(storeMapper.lockStallForPayment(11L)).thenReturn(11L);

        controller.activate(com.ruoyi.system.utils.JwtUtil.setToken("101", "test"), 7L);

        org.mockito.InOrder order = inOrder(storeMapper, cardMapper);
        order.verify(storeMapper).lockStallForPayment(11L);
        order.verify(cardMapper).selectById(7L);
        order.verify(cardMapper, org.mockito.Mockito.times(2)).update(any(), any());
    }

    @Test
    void firstStallCardIsCountedOnlyAfterStallLock() {
        when(storeMapper.lockStallForPayment(11L)).thenReturn(11L);
        when(cardMapper.selectCount(any())).thenReturn(0L);
        SysDictData bank = new SysDictData();
        bank.setDictLabel("银行");
        BankCardSaveDto dto = new BankCardSaveDto();
        dto.setBankName("银行");
        dto.setAccountNo("123");
        dto.setAccountName("摊位");

        try (org.mockito.MockedStatic<DictUtils> dict = org.mockito.Mockito.mockStatic(DictUtils.class)) {
            dict.when(() -> DictUtils.getDictCache("taiwan_bank_list"))
                    .thenReturn(java.util.List.of(bank));
            controller.add(com.ruoyi.system.utils.JwtUtil.setToken("101", "test"), dto);
        }

        org.mockito.InOrder order = inOrder(storeMapper, cardMapper);
        order.verify(storeMapper).lockStallForPayment(11L);
        order.verify(cardMapper).selectCount(any());
        ArgumentCaptor<InfoBankCard> inserted = ArgumentCaptor.forClass(InfoBankCard.class);
        order.verify(cardMapper).insert(inserted.capture());
        assertTrue(inserted.getValue().getIsActive() == 1);
        assertTrue(inserted.getValue().getStoreId() == 11L);
    }
}