|
|
@@ -0,0 +1,407 @@
|
|
|
+package com.etotem.cfc.unit;
|
|
|
+
|
|
|
+import com.etotem.cfc.entity.Family;
|
|
|
+import com.etotem.cfc.entity.FamilyInvitation;
|
|
|
+import com.etotem.cfc.entity.FamilyJoinRequest;
|
|
|
+import com.etotem.cfc.entity.FamilyMember;
|
|
|
+import com.etotem.cfc.entity.User;
|
|
|
+import com.etotem.cfc.mapper.FamilyInvitationMapper;
|
|
|
+import com.etotem.cfc.mapper.FamilyJoinRequestMapper;
|
|
|
+import com.etotem.cfc.mapper.FamilyMapper;
|
|
|
+import com.etotem.cfc.mapper.FamilyMemberMapper;
|
|
|
+import com.etotem.cfc.mapper.UserMapper;
|
|
|
+import com.etotem.cfc.service.FamilyInvitationService;
|
|
|
+import com.etotem.cfc.service.FamilyJoinRequestService;
|
|
|
+import com.etotem.cfc.service.FamilyRelationshipService;
|
|
|
+import org.junit.jupiter.api.BeforeEach;
|
|
|
+import org.junit.jupiter.api.DisplayName;
|
|
|
+import org.junit.jupiter.api.Test;
|
|
|
+import org.mockito.ArgumentCaptor;
|
|
|
+import org.mockito.InjectMocks;
|
|
|
+import org.mockito.Mock;
|
|
|
+import org.mockito.MockitoAnnotations;
|
|
|
+
|
|
|
+import java.text.ParseException;
|
|
|
+import java.text.SimpleDateFormat;
|
|
|
+import java.util.Date;
|
|
|
+import java.util.concurrent.atomic.AtomicInteger;
|
|
|
+
|
|
|
+import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
|
+import static org.junit.jupiter.api.Assertions.assertNotNull;
|
|
|
+import static org.junit.jupiter.api.Assertions.assertThrows;
|
|
|
+import static org.junit.jupiter.api.Assertions.assertTrue;
|
|
|
+import static org.mockito.ArgumentMatchers.any;
|
|
|
+import static org.mockito.ArgumentMatchers.eq;
|
|
|
+import static org.mockito.ArgumentMatchers.isNull;
|
|
|
+import static org.mockito.Mockito.doAnswer;
|
|
|
+import static org.mockito.Mockito.never;
|
|
|
+import static org.mockito.Mockito.times;
|
|
|
+import static org.mockito.Mockito.verify;
|
|
|
+import static org.mockito.Mockito.when;
|
|
|
+
|
|
|
+/**
|
|
|
+ * 契约测试:能力键 {@code family.invite.memberJoin}(S-cfc-257,SC-P-02 + SC-P-09)。
|
|
|
+ *
|
|
|
+ * <p><b>需求溯源(tests/user-scenarios/应用场景总览.md SC-P-02/SC-P-09 · tests/test-cases/parent.md TC-P-02/TC-P-02-B/TC-P-02-E)</b></p>
|
|
|
+ * <ul>
|
|
|
+ * <li>SC-P-02 · 邀请成员 + 关系编辑:分享邀请 → 成员加入 → {@code RelationshipPicker} 选关系 → 关系图更新。
|
|
|
+ * 对应 TC-P-02(邀请码/二维码加入 → C 加入家庭,成员列表出现 C)、TC-P-02-B(C 申请加入 → 家长审批 → 成为家庭成员)。</li>
|
|
|
+ * <li>SC-P-09 · 邀请码失效/重生成:旧码作废换新;边界——旧码已加入的会员不受影响。</li>
|
|
|
+ * <li>TC-P-02-E · 异常流:过期邀请码(>7 天) → 提示『邀请已失效,请重新获取』;均不建立成员关系。</li>
|
|
|
+ * </ul>
|
|
|
+ *
|
|
|
+ * <p><b>设计锚点(API_REFERENCE §4.2 家庭与成员 / FamilyJoinRequestService + FamilyInvitationService)</b></p>
|
|
|
+ * <ul>
|
|
|
+ * <li>申请加入:{@code POST /api/family/invite/request-join-by-code} → {@link FamilyJoinRequestService#createJoinRequest}
|
|
|
+ * (令牌路径绑定邀请人、校验准入信息、查重待审批、创建 pending 请求)。</li>
|
|
|
+ * <li>审批加入:{@code POST /api/family/invite/approve-request} → {@link FamilyJoinRequestService#approveJoinRequest}
|
|
|
+ * (身份由邀请人指定:generationLevel 辈分 + peerType 同辈类型;落地 familyId/FamilyMember/关系/request→approved)。</li>
|
|
|
+ * <li>邀请令牌校验:{@link FamilyInvitationService#validateInvitation}(active + 未过期 + 未超最大使用次数)。</li>
|
|
|
+ * </ul>
|
|
|
+ *
|
|
|
+ * <p><b>RED 预期</b>(当前实现未完全落地 → 下列断言应红,GREEN 阶段补齐):</p>
|
|
|
+ * <ol>
|
|
|
+ * <li>TC-P-02-E 过期/失效邀请提示文案未对齐:契约要求 message 含『邀请已失效』,当前抛「邀请令牌无效或已过期」→ 文案断言红;</li>
|
|
|
+ * <li>审批身份校验缺口:非 {@code peer} 辈分却携带 {@code peerType}(如 parent+spouse)被静默忽略而非拒绝 → 应红;</li>
|
|
|
+ * <li>SC-P-09 短邀请码「重生成/作废换新」入口缺失(对照 supply-team {@code refresh=true} 重置旧码立即失效):
|
|
|
+ * {@code families.invite_code} 为单值永久码、无失效字段,旧码无法作废;属新增入口,本类在 javadoc 记录缺口,GREEN 阶段新增
|
|
|
+ * {@code POST /api/family/invite/reissue}(重置 invite_code)后回归。</li>
|
|
|
+ * </ol>
|
|
|
+ *
|
|
|
+ * <p><b>测试范围</b>:纯 Mockito(无 Spring 容器 / 无 DB / 无真实微信),直测 {@link FamilyJoinRequestService}
|
|
|
+ * 服务契约;风格与同批 CONTRACT 测试(FamilyJoinValidationRulesContractTest)一致。</p>
|
|
|
+ */
|
|
|
+class FamilyInviteMemberJoinContractTest {
|
|
|
+
|
|
|
+ private static final String KEY = "[family.invite.memberJoin]";
|
|
|
+ private static final Long TARGET_FAMILY_ID = 100L;
|
|
|
+ private static final Long REQUESTER_USER_ID = 200L;
|
|
|
+ private static final Long APPROVER_USER_ID = 300L;
|
|
|
+ private static final Long INVITER_USER_ID = 300L; // 审批人=邀请人(谁分享的卡谁确认)
|
|
|
+ private static final Long ANCHOR_MEMBER_ID = 900L; // 审批人在本家庭的成员记录(关系锚点)
|
|
|
+ private static final Long NEW_MEMBER_ID = 901L; // 新加入成员(insert 后由 DB 自增回填,契约测试模拟回填)
|
|
|
+ private static final Long REQUEST_ID = 1001L;
|
|
|
+ private static final String VALID_TOKEN = "0123456789abcdef0123456789abcdef"; // 32 位 hex
|
|
|
+ private static final String LEGACY_JOIN_MESSAGE = "请先完善真实姓名、出生日期与性别后再申请加入家庭";
|
|
|
+
|
|
|
+ @Mock
|
|
|
+ private FamilyInvitationMapper familyInvitationMapper;
|
|
|
+
|
|
|
+ @Mock
|
|
|
+ private FamilyJoinRequestMapper familyJoinRequestMapper;
|
|
|
+
|
|
|
+ @Mock
|
|
|
+ private FamilyMapper familyMapper;
|
|
|
+
|
|
|
+ @Mock
|
|
|
+ private FamilyMemberMapper familyMemberMapper;
|
|
|
+
|
|
|
+ @Mock
|
|
|
+ private UserMapper userMapper;
|
|
|
+
|
|
|
+ @Mock
|
|
|
+ private FamilyInvitationService familyInvitationService;
|
|
|
+
|
|
|
+ @Mock
|
|
|
+ private FamilyRelationshipService familyRelationshipService;
|
|
|
+
|
|
|
+ @InjectMocks
|
|
|
+ private FamilyJoinRequestService service;
|
|
|
+
|
|
|
+ @BeforeEach
|
|
|
+ void setUp() {
|
|
|
+ MockitoAnnotations.openMocks(this);
|
|
|
+ }
|
|
|
+
|
|
|
+ // ====================================================================
|
|
|
+ // SC-P-02 申请加入(request-join-by-code → createJoinRequest)
|
|
|
+ // ====================================================================
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【服务-正常锚点·申请】合法令牌路径绑定邀请人,创建待审批请求(GREEN 锚点)")
|
|
|
+ void 申请_令牌路径_绑定邀请人_创建待审批请求() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, null));
|
|
|
+ when(familyInvitationMapper.selectOne(any())).thenReturn(activeInvitation());
|
|
|
+ when(familyJoinRequestMapper.selectOne(any())).thenReturn(null);
|
|
|
+
|
|
|
+ FamilyJoinRequest created = service.createJoinRequest(REQUESTER_USER_ID, VALID_TOKEN, null);
|
|
|
+
|
|
|
+ assertNotNull(created, KEY + " 令牌路径应创建申请记录");
|
|
|
+ assertEquals("pending", created.getStatus(), KEY + " 申请应进入待审批状态");
|
|
|
+ assertEquals(REQUESTER_USER_ID, created.getRequesterUserId());
|
|
|
+ assertEquals(TARGET_FAMILY_ID, created.getTargetFamilyId());
|
|
|
+ assertEquals(INVITER_USER_ID, created.getInviterUserId(), KEY + " 令牌路径应绑定邀请人作为审批人");
|
|
|
+ assertEquals("by_token", created.getJoinMethod(), KEY + " 令牌路径 joinMethod 应为 by_token");
|
|
|
+ verify(familyJoinRequestMapper).insert(any(FamilyJoinRequest.class));
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【服务-边界·SC-P-09】已入家庭者重复申请被拒,不落库(旧码失效不影响已加入会员:不允许重复加入)")
|
|
|
+ void 申请_已入家庭者_拒绝加入_不落库() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ // 已属目标家庭
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ when(familyInvitationMapper.selectOne(any())).thenReturn(activeInvitation());
|
|
|
+
|
|
|
+ RuntimeException ex = assertThrows(RuntimeException.class,
|
|
|
+ () -> service.createJoinRequest(REQUESTER_USER_ID, VALID_TOKEN, null));
|
|
|
+ assertEquals("您已是该家庭成员", ex.getMessage());
|
|
|
+ verify(familyJoinRequestMapper, never()).insert(any(FamilyJoinRequest.class));
|
|
|
+ }
|
|
|
+
|
|
|
+ // ====================================================================
|
|
|
+ // SC-P-02 审批加入(approve-request → approveJoinRequest)
|
|
|
+ // ====================================================================
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【服务-正常流·无身份旧路径】审批通过:用户入家庭 + 创建 FamilyMember + 请求置为已通过(GREEN 锚点)")
|
|
|
+ void 审批_无身份旧路径_加入家庭_创建成员_请求通过() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ stubRequest("pending", INVITER_USER_ID);
|
|
|
+ when(userMapper.selectById(APPROVER_USER_ID)).thenReturn(memberUser(APPROVER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, null));
|
|
|
+ // 无既有成员记录 → 创建新成员
|
|
|
+ when(familyMemberMapper.selectOne(any())).thenReturn(null);
|
|
|
+
|
|
|
+ service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "同意加入");
|
|
|
+
|
|
|
+ ArgumentCaptor<User> userCap = ArgumentCaptor.forClass(User.class);
|
|
|
+ verify(userMapper).updateById(userCap.capture());
|
|
|
+ assertEquals(TARGET_FAMILY_ID, userCap.getValue().getFamilyId(), KEY + " 申请人 familyId 应更新为目标家庭");
|
|
|
+ verify(familyMemberMapper).insert(any(FamilyMember.class));
|
|
|
+
|
|
|
+ ArgumentCaptor<FamilyJoinRequest> reqCap = ArgumentCaptor.forClass(FamilyJoinRequest.class);
|
|
|
+ verify(familyJoinRequestMapper).updateById(reqCap.capture());
|
|
|
+ assertEquals("approved", reqCap.getValue().getStatus(), KEY + " 审批通过后请求应置为 approved");
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【服务-正常流·选关系】指定辈分 parent:关系服务被调用 + 推导角色『爸爸』+ 回写申请表(GREEN 锚点)")
|
|
|
+ void 审批_指定辈分parent_关系落地_推导爸爸() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ stubRequest("pending", INVITER_USER_ID);
|
|
|
+ when(userMapper.selectById(APPROVER_USER_ID)).thenReturn(memberUser(APPROVER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ stubMemberSelect(APPROVER_USER_ID, 0);
|
|
|
+ stubMemberInsertWithId();
|
|
|
+
|
|
|
+ service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "选为爸爸", "parent", null);
|
|
|
+
|
|
|
+ verify(familyRelationshipService).createRelationsForNewMember(
|
|
|
+ eq(TARGET_FAMILY_ID), eq(NEW_MEMBER_ID), eq(1), isNull(), eq(ANCHOR_MEMBER_ID));
|
|
|
+
|
|
|
+ ArgumentCaptor<User> userCap = ArgumentCaptor.forClass(User.class);
|
|
|
+ verify(userMapper).updateById(userCap.capture());
|
|
|
+ assertEquals("爸爸", userCap.getValue().getFamilyRole(), KEY + " 绝对辈分1+男 → 家庭角色应推导为爸爸");
|
|
|
+ assertEquals(TARGET_FAMILY_ID, userCap.getValue().getFamilyId());
|
|
|
+
|
|
|
+ ArgumentCaptor<FamilyJoinRequest> reqCap = ArgumentCaptor.forClass(FamilyJoinRequest.class);
|
|
|
+ verify(familyJoinRequestMapper).updateById(reqCap.capture());
|
|
|
+ assertEquals(Integer.valueOf(1), reqCap.getValue().getAssignedGeneration(), KEY + " 申请表应回写 assignedGeneration");
|
|
|
+ assertEquals("爸爸", reqCap.getValue().getFamilyRole(), KEY + " 申请表应回写推导 familyRole");
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【服务-正常流·同辈配偶】peer+spouse:配偶标记 + 仅对锚点建立配偶关系(GREEN 锚点)")
|
|
|
+ void 审批_同辈配偶_锚点配偶关系落地() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ stubRequest("pending", INVITER_USER_ID);
|
|
|
+ when(userMapper.selectById(APPROVER_USER_ID)).thenReturn(memberUser(APPROVER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ stubMemberSelect(APPROVER_USER_ID, 0);
|
|
|
+ stubMemberInsertWithId();
|
|
|
+
|
|
|
+ service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "选为配偶", "peer", "spouse");
|
|
|
+
|
|
|
+ verify(familyRelationshipService).createRelationsForNewMember(
|
|
|
+ eq(TARGET_FAMILY_ID), eq(NEW_MEMBER_ID), eq(0), eq("spouse"), eq(ANCHOR_MEMBER_ID));
|
|
|
+
|
|
|
+ ArgumentCaptor<FamilyMember> memberCap = ArgumentCaptor.forClass(FamilyMember.class);
|
|
|
+ verify(familyMemberMapper).updateById(memberCap.capture());
|
|
|
+ assertTrue(memberCap.getValue().getIsSpouse(), KEY + " 同辈配偶应落 isSpouse=true");
|
|
|
+ }
|
|
|
+
|
|
|
+ // ====================================================================
|
|
|
+ // 异常流 / 权限流
|
|
|
+ // ====================================================================
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【异常流·重复审批】已处理请求再次审批 → 『该请求已处理』(幂等守卫)")
|
|
|
+ void 审批_重复审批_抛已处理() {
|
|
|
+ stubRequest("approved", INVITER_USER_ID);
|
|
|
+
|
|
|
+ RuntimeException ex = assertThrows(RuntimeException.class,
|
|
|
+ () -> service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "重复审批", "parent", null));
|
|
|
+ assertEquals("该请求已处理", ex.getMessage());
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【权限流·越权审批】非邀请人审批 → 『只有邀请人才能处理该申请』(TC-P-02-P)")
|
|
|
+ void 审批_越权非邀请人_拒绝() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ // 请求绑定的邀请人非当前审批人
|
|
|
+ stubRequest("pending", 999L);
|
|
|
+ when(userMapper.selectById(APPROVER_USER_ID)).thenReturn(memberUser(APPROVER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+
|
|
|
+ RuntimeException ex = assertThrows(RuntimeException.class,
|
|
|
+ () -> service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "越权"));
|
|
|
+ assertEquals("只有邀请人才能处理该申请", ex.getMessage());
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【异常流·辈分非法】generationLevel 非枚举值 → 『请选择辈分关系』")
|
|
|
+ void 审批_辈分非法值_拒绝() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ stubRequest("pending", INVITER_USER_ID);
|
|
|
+ when(userMapper.selectById(APPROVER_USER_ID)).thenReturn(memberUser(APPROVER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+
|
|
|
+ RuntimeException ex = assertThrows(RuntimeException.class,
|
|
|
+ () -> service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "非法辈分", "alien", null));
|
|
|
+ assertEquals("请选择辈分关系", ex.getMessage());
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【异常流·peer 缺同辈类型】peer 未选同辈关系类型 → 『请选择同辈关系类型』")
|
|
|
+ void 审批_peer缺同辈类型_拒绝() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ stubRequest("pending", INVITER_USER_ID);
|
|
|
+ when(userMapper.selectById(APPROVER_USER_ID)).thenReturn(memberUser(APPROVER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+
|
|
|
+ RuntimeException ex = assertThrows(RuntimeException.class,
|
|
|
+ () -> service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "peer 无类型", "peer", null));
|
|
|
+ assertEquals("请选择同辈关系类型", ex.getMessage());
|
|
|
+ }
|
|
|
+
|
|
|
+ // ====================================================================
|
|
|
+ // RED 预期(GREEN 阶段补齐)
|
|
|
+ // ====================================================================
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【异常流·过期邀请】失效/过期令牌提示文案应对齐契约『邀请已失效』→ RED(当前文案为「邀请令牌无效或已过期」)")
|
|
|
+ void 申请_过期邀请_提示应含邀请已失效() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, null));
|
|
|
+ // 令牌已过期/非 active → 查询不命中
|
|
|
+ when(familyInvitationMapper.selectOne(any())).thenReturn(null);
|
|
|
+
|
|
|
+ RuntimeException ex = assertThrows(RuntimeException.class,
|
|
|
+ () -> service.createJoinRequest(REQUESTER_USER_ID, VALID_TOKEN, null));
|
|
|
+ assertTrue(ex.getMessage() != null && ex.getMessage().contains("邀请已失效"),
|
|
|
+ KEY + " TC-P-02-E 要求过期邀请提示含『邀请已失效,请重新获取』;实际: " + ex.getMessage());
|
|
|
+ verify(familyJoinRequestMapper, never()).insert(any(FamilyJoinRequest.class));
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ @DisplayName("【异常流·身份校验】非 peer 辈分携带 peerType 应被拒绝 → RED(当前静默忽略)")
|
|
|
+ void 审批_非peer辈分携带peerType_应拒绝() {
|
|
|
+ stubFamily(TARGET_FAMILY_ID);
|
|
|
+ stubRequest("pending", INVITER_USER_ID);
|
|
|
+ when(userMapper.selectById(APPROVER_USER_ID)).thenReturn(memberUser(APPROVER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ when(userMapper.selectById(REQUESTER_USER_ID)).thenReturn(validUser(REQUESTER_USER_ID, TARGET_FAMILY_ID));
|
|
|
+ stubMemberSelect(APPROVER_USER_ID, 0);
|
|
|
+
|
|
|
+ // 契约:同辈类型仅对 peer 辈分合法,parent+spouse 属非法输入应拒绝
|
|
|
+ assertThrows(RuntimeException.class,
|
|
|
+ () -> service.approveJoinRequest(REQUEST_ID, APPROVER_USER_ID, "parent 带同辈类型", "parent", "spouse"),
|
|
|
+ KEY + " 非 peer 辈分携带 peerType 应被拒绝(当前静默忽略 peerType)");
|
|
|
+ }
|
|
|
+
|
|
|
+ // ====================================================================
|
|
|
+ // 辅助构造
|
|
|
+ // ====================================================================
|
|
|
+
|
|
|
+ private void stubFamily(Long familyId) {
|
|
|
+ Family family = new Family();
|
|
|
+ family.setId(familyId);
|
|
|
+ family.setName("契约测试家庭");
|
|
|
+ family.setInviteCode("fam_contract_test");
|
|
|
+ when(familyMapper.selectById(familyId)).thenReturn(family);
|
|
|
+ }
|
|
|
+
|
|
|
+ private void stubRequest(String status, Long inviterUserId) {
|
|
|
+ FamilyJoinRequest req = new FamilyJoinRequest();
|
|
|
+ req.setId(REQUEST_ID);
|
|
|
+ req.setRequesterUserId(REQUESTER_USER_ID);
|
|
|
+ req.setTargetFamilyId(TARGET_FAMILY_ID);
|
|
|
+ req.setInviterUserId(inviterUserId);
|
|
|
+ req.setStatus(status);
|
|
|
+ when(familyJoinRequestMapper.selectById(REQUEST_ID)).thenReturn(req);
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 审批人=目标家庭成员(isMember 判定通过) */
|
|
|
+ private User memberUser(Long id, Long familyId) {
|
|
|
+ User u = new User();
|
|
|
+ u.setId(id);
|
|
|
+ u.setFamilyId(familyId);
|
|
|
+ return u;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 申请人:已完善准入信息(姓名/生日/性别),可申请加入 */
|
|
|
+ private User validUser(Long id, Long familyId) {
|
|
|
+ User u = new User();
|
|
|
+ u.setId(id);
|
|
|
+ u.setRealName("张三");
|
|
|
+ u.setBirthday(date("1990-05-01"));
|
|
|
+ u.setGender("male");
|
|
|
+ u.setFamilyId(familyId);
|
|
|
+ u.setNickname("张三");
|
|
|
+ u.setAvatar("/static/avatar.jpg");
|
|
|
+ u.setReferrerId(0L); // 已有推荐人 → 跳过推荐人绑定,避免依赖 commissionService
|
|
|
+ return u;
|
|
|
+ }
|
|
|
+
|
|
|
+ private FamilyInvitation activeInvitation() {
|
|
|
+ FamilyInvitation inv = new FamilyInvitation();
|
|
|
+ inv.setId(1L);
|
|
|
+ inv.setFamilyId(TARGET_FAMILY_ID);
|
|
|
+ inv.setToken(VALID_TOKEN);
|
|
|
+ inv.setCreatedBy(INVITER_USER_ID);
|
|
|
+ inv.setStatus("active");
|
|
|
+ inv.setExpiresAt(new Date(System.currentTimeMillis() + 7 * 24 * 60 * 60 * 1000L));
|
|
|
+ inv.setMaxUseCount(1);
|
|
|
+ inv.setUsedCount(0);
|
|
|
+ return inv;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * familyMemberMapper.selectOne 按调用次序区分(withIdentity 路径固定先锚点后成员):
|
|
|
+ * ① 第一次调用 = 锚点查询(审批人成员记录,generation=0)→ 返回 ANCHOR_MEMBER_ID 的成员;
|
|
|
+ * ② 第二次调用 = 申请人成员查询(不存在)→ 返回 null(走兜底创建,insert 回填 NEW_MEMBER_ID)。
|
|
|
+ */
|
|
|
+ private void stubMemberSelect(Long anchorUserId, int anchorGeneration) {
|
|
|
+ AtomicInteger callIndex = new AtomicInteger();
|
|
|
+ when(familyMemberMapper.selectOne(any())).thenAnswer(invocation -> {
|
|
|
+ if (callIndex.getAndIncrement() == 0) {
|
|
|
+ FamilyMember anchor = new FamilyMember();
|
|
|
+ anchor.setId(ANCHOR_MEMBER_ID);
|
|
|
+ anchor.setFamilyId(TARGET_FAMILY_ID);
|
|
|
+ anchor.setUserId(anchorUserId);
|
|
|
+ anchor.setGeneration(anchorGeneration);
|
|
|
+ return anchor;
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ /** 模拟 DB 自增回填主键:兜底创建成员后 insert 需回填 id,关系服务才拿到新成员 id */
|
|
|
+ private void stubMemberInsertWithId() {
|
|
|
+ doAnswer(invocation -> {
|
|
|
+ FamilyMember m = invocation.getArgument(0);
|
|
|
+ m.setId(NEW_MEMBER_ID);
|
|
|
+ return 1;
|
|
|
+ }).when(familyMemberMapper).insert(any(FamilyMember.class));
|
|
|
+ }
|
|
|
+
|
|
|
+ private Date date(String yyyyMMdd) {
|
|
|
+ try {
|
|
|
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
|
|
+ sdf.setLenient(false);
|
|
|
+ return sdf.parse(yyyyMMdd);
|
|
|
+ } catch (ParseException e) {
|
|
|
+ throw new IllegalArgumentException("非法测试日期: " + yyyyMMdd, e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|