jsowell-charger-web/jsowell-admin/src/test/java/com/jsowell/service/TempServiceImportMemberBalanceTest.java

package com.jsowell.service;

import com.jsowell.pile.dto.BatchImportMemberBalanceResultDTO;
import com.jsowell.common.enums.MemberWalletEnum;
import com.jsowell.pile.domain.MemberBasicInfo;
import com.jsowell.pile.dto.ImportMemberBalanceDTO;
import com.jsowell.pile.dto.ImportMemberBalanceItemResultDTO;
import com.jsowell.pile.dto.MemberRegisterAndLoginDTO;
import com.jsowell.pile.service.MemberBasicInfoService;
import com.jsowell.pile.vo.web.UpdateMemberBalanceDTO;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Arrays;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

class TempServiceImportMemberBalanceTest {

    @Test
    void importMemberBalance_shouldIncreaseWalletBalance_whenMemberAlreadyExists() throws Exception {
        MemberBasicInfoService memberBasicInfoService = mock(MemberBasicInfoService.class);
        MemberService memberService = mock(MemberService.class);

        MemberBasicInfo memberBasicInfo = MemberBasicInfo.builder()
                .memberId("M1001")
                .mobileNumber("13800000001")
                .merchantId(1L)
                .build();
        when(memberBasicInfoService.selectInfoByMobileNumber("13800000001", "1")).thenReturn(memberBasicInfo);

        TempService tempService = newTempService(memberBasicInfoService, memberService);
        ImportMemberBalanceDTO dto = new ImportMemberBalanceDTO();
        dto.setPhone("13800000001");
        dto.setBalance(new BigDecimal("88.50"));

        invokeImportMemberBalance(tempService, dto);

        verify(memberService, never()).memberRegisterAndLoginV2(any(MemberRegisterAndLoginDTO.class));

        ArgumentCaptor<UpdateMemberBalanceDTO> captor = ArgumentCaptor.forClass(UpdateMemberBalanceDTO.class);
        verify(memberBasicInfoService).updateMemberBalance(captor.capture());
        UpdateMemberBalanceDTO updateDto = captor.getValue();
        assertEquals("M1001", updateDto.getMemberId());
        assertEquals(MemberWalletEnum.TYPE_IN.getValue(), updateDto.getType());
        assertEquals(MemberWalletEnum.SUBTYPE_TOP_UP.getValue(), updateDto.getSubType());
        assertEquals(new BigDecimal("88.50"), updateDto.getUpdatePrincipalBalance());
        assertEquals("575", updateDto.getTargetMerchantId());
    }

    @Test
    void importMemberBalance_shouldRegisterMemberBeforeIncreaseBalance_whenMemberDoesNotExist() throws Exception {
        MemberBasicInfoService memberBasicInfoService = mock(MemberBasicInfoService.class);
        MemberService memberService = mock(MemberService.class);

        MemberBasicInfo memberBasicInfo = MemberBasicInfo.builder()
                .memberId("M2002")
                .mobileNumber("13800000002")
                .merchantId(1L)
                .build();
        when(memberBasicInfoService.selectInfoByMobileNumber("13800000002", "1")).thenReturn(null, memberBasicInfo);

        TempService tempService = newTempService(memberBasicInfoService, memberService);
        ImportMemberBalanceDTO dto = new ImportMemberBalanceDTO();
        dto.setPhone("13800000002");
        dto.setBalance(new BigDecimal("100"));

        invokeImportMemberBalance(tempService, dto);

        ArgumentCaptor<MemberRegisterAndLoginDTO> loginCaptor = ArgumentCaptor.forClass(MemberRegisterAndLoginDTO.class);
        verify(memberService).memberRegisterAndLoginV2(loginCaptor.capture());
        MemberRegisterAndLoginDTO loginDTO = loginCaptor.getValue();
        assertEquals("13800000002", loginDTO.getMobileNumber());
        assertEquals("1", loginDTO.getFirstLevelMerchantId());

        ArgumentCaptor<UpdateMemberBalanceDTO> balanceCaptor = ArgumentCaptor.forClass(UpdateMemberBalanceDTO.class);
        verify(memberBasicInfoService).updateMemberBalance(balanceCaptor.capture());
        assertEquals("M2002", balanceCaptor.getValue().getMemberId());
        assertEquals("575", balanceCaptor.getValue().getTargetMerchantId());
        assertEquals(new BigDecimal("100"), balanceCaptor.getValue().getUpdatePrincipalBalance());
    }

    @Test
    void batchImportMemberBalance_shouldReturnSummary_whenMixedRecords() {
        MemberBasicInfoService memberBasicInfoService = mock(MemberBasicInfoService.class);
        MemberService memberService = mock(MemberService.class);

        MemberBasicInfo memberBasicInfo = MemberBasicInfo.builder()
                .memberId("M3003")
                .mobileNumber("13800000003")
                .merchantId(1L)
                .build();
        when(memberBasicInfoService.selectInfoByMobileNumber("13800000003", "1")).thenReturn(memberBasicInfo);

        TempService tempService = newTempService(memberBasicInfoService, memberService);

        ImportMemberBalanceDTO successDto = new ImportMemberBalanceDTO();
        successDto.setPhone("13800000003");
        successDto.setBalance(new BigDecimal("50"));

        ImportMemberBalanceDTO failDto = new ImportMemberBalanceDTO();
        failDto.setPhone("");
        failDto.setBalance(new BigDecimal("20"));

        BatchImportMemberBalanceResultDTO result = tempService.batchImportMemberBalance(Arrays.asList(successDto, failDto));

        assertNotNull(result);
        assertEquals(2, result.getTotalCount());
        assertEquals(1, result.getSuccessCount());
        assertEquals(1, result.getFailCount());
        assertEquals(1, result.getFailedList().size());
        ImportMemberBalanceItemResultDTO failedItem = result.getFailedList().get(0);
        assertEquals("", failedItem.getPhone());
    }

    private static TempService newTempService(MemberBasicInfoService memberBasicInfoService, MemberService memberService) {
        TempService tempService = new TempService();
        setField(tempService, "memberBasicInfoService", memberBasicInfoService);
        setField(tempService, "memberService", memberService);
        return tempService;
    }

    private static void invokeImportMemberBalance(TempService tempService, ImportMemberBalanceDTO dto) throws Exception {
        Method method = TempService.class.getDeclaredMethod("importMemberBalance", ImportMemberBalanceDTO.class);
        method.setAccessible(true);
        method.invoke(tempService, dto);
    }

    private static void setField(Object target, String fieldName, Object value) {
        try {
            Field field = target.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}