package com.talentcard.server.service;
|
|
import static org.assertj.core.api.Assertions.assertThat;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.Mockito.never;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
import java.util.List;
|
|
import com.baomidou.mybatisplus.core.MybatisConfiguration;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
|
import com.talentcard.server.entity.DependentCardApply;
|
import com.talentcard.server.entity.DependentCardApplyStatusLog;
|
import com.talentcard.server.mapper.DependentCardApplyMapper;
|
import com.talentcard.server.mapper.DependentCardApplyStatusLogMapper;
|
import com.talentcard.server.request.DependentCardApplyRequest;
|
import com.talentcard.server.response.DependentCardApplyItemResponse;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.Test;
|
import org.junit.jupiter.api.extension.ExtendWith;
|
import org.apache.ibatis.builder.MapperBuilderAssistant;
|
import org.mockito.ArgumentCaptor;
|
import org.mockito.Mock;
|
import org.mockito.junit.jupiter.MockitoExtension;
|
|
@ExtendWith(MockitoExtension.class)
|
class DependentCardApplyServiceTests {
|
|
@Mock
|
private DependentCardApplyMapper mapper;
|
@Mock
|
private DependentCardApplyStatusLogMapper statusLogMapper;
|
|
private DependentCardApplyService service;
|
|
@BeforeEach
|
void setUp() {
|
TableInfoHelper.initTableInfo(
|
new MapperBuilderAssistant(new MybatisConfiguration(), "dependent-card-test"),
|
DependentCardApply.class
|
);
|
service = new DependentCardApplyService(mapper, statusLogMapper);
|
}
|
|
@Test
|
void listExcludesCancelledFamilyCards() {
|
when(mapper.selectList(any(Wrapper.class))).thenReturn(List.of());
|
|
service.list(34L);
|
|
ArgumentCaptor<LambdaQueryWrapper<DependentCardApply>> queryCaptor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
|
verify(mapper).selectList(queryCaptor.capture());
|
LambdaQueryWrapper<DependentCardApply> query = queryCaptor.getValue();
|
assertThat(query.getSqlSegment()).contains("talent_card_id", "status <>");
|
assertThat(query.getParamNameValuePairs()).containsValue(34L).containsValue(DependentCardApply.STATUS_CANCELLED);
|
}
|
|
@Test
|
void resubmitCreatesANewApplicationAndKeepsRejectedApplicationUnchanged() {
|
DependentCardApply rejected = new DependentCardApply(
|
"DCA-OLD",
|
12L,
|
34L,
|
"持卡人",
|
"13900000000",
|
"TC-001",
|
"卓越人才卡",
|
"旧家属",
|
"13800000000",
|
"510105199001011234",
|
"配偶"
|
);
|
setStatus(rejected, DependentCardApply.STATUS_REJECTED);
|
when(mapper.selectByIdForUpdate(99L)).thenReturn(rejected);
|
when(mapper.insert(any(DependentCardApply.class))).thenAnswer(invocation -> {
|
setId(invocation.getArgument(0), 100L);
|
return 1;
|
});
|
when(statusLogMapper.insert(any(DependentCardApplyStatusLog.class))).thenReturn(1);
|
|
DependentCardApplyItemResponse result = service.resubmit(
|
99L,
|
new DependentCardApplyRequest(
|
34L,
|
" 新家属 ",
|
"51010519900101123X",
|
"13700000000",
|
" 子女 "
|
)
|
);
|
|
ArgumentCaptor<DependentCardApply> applicationCaptor = ArgumentCaptor.forClass(DependentCardApply.class);
|
verify(mapper).insert(applicationCaptor.capture());
|
DependentCardApply created = applicationCaptor.getValue();
|
assertThat(created.getId()).isEqualTo(100L);
|
assertThat(created.getApplyNo()).startsWith("DCA").isNotEqualTo(rejected.getApplyNo());
|
assertThat(created.getTalentId()).isEqualTo(rejected.getTalentId());
|
assertThat(created.getTalentCardId()).isEqualTo(rejected.getTalentCardId());
|
assertThat(created.getDependentName()).isEqualTo("新家属");
|
assertThat(created.getDependentIdCardNo()).isEqualTo("51010519900101123X");
|
assertThat(created.getDependentMobile()).isEqualTo("13700000000");
|
assertThat(created.getRelation()).isEqualTo("子女");
|
assertThat(created.getStatus()).isEqualTo(DependentCardApply.STATUS_PENDING_REVIEW);
|
assertThat(result.id()).isEqualTo(100L);
|
assertThat(result.status()).isEqualTo(DependentCardApply.STATUS_PENDING_REVIEW);
|
assertThat(rejected.getStatus()).isEqualTo(DependentCardApply.STATUS_REJECTED);
|
verify(mapper, never()).update(any(), any(Wrapper.class));
|
|
ArgumentCaptor<DependentCardApplyStatusLog> logCaptor = ArgumentCaptor.forClass(DependentCardApplyStatusLog.class);
|
verify(statusLogMapper).insert(logCaptor.capture());
|
assertThat(logCaptor.getValue().getApplyId()).isEqualTo(100L);
|
assertThat(logCaptor.getValue().getApplyNo()).isEqualTo(created.getApplyNo());
|
assertThat(logCaptor.getValue().getFromStatus()).isNull();
|
assertThat(logCaptor.getValue().getToStatus()).isEqualTo(DependentCardApply.STATUS_PENDING_REVIEW);
|
}
|
|
private void setId(DependentCardApply apply, Long id) {
|
setField(apply, "id", id);
|
}
|
|
private void setStatus(DependentCardApply apply, Integer status) {
|
setField(apply, "status", status);
|
}
|
|
private void setField(DependentCardApply apply, String name, Object value) {
|
try {
|
var field = DependentCardApply.class.getDeclaredField(name);
|
field.setAccessible(true);
|
field.set(apply, value);
|
} catch (ReflectiveOperationException exception) {
|
throw new AssertionError(exception);
|
}
|
}
|
}
|
