baiyue-firstleg/iam/src/test/java/com/baiyue/iam/notification/NotificationRecipientResolverTest.java

package com.baiyue.iam.notification;

import com.baiyue.common.core.exception.BizException;
import com.baiyue.iam.entity.IamMembership;
import com.baiyue.iam.entity.IamMembershipRole;
import com.baiyue.iam.entity.IamRole;
import com.baiyue.iam.entity.IamUser;
import com.baiyue.iam.mapper.IamMembershipMapper;
import com.baiyue.iam.mapper.IamMembershipRoleMapper;
import com.baiyue.iam.mapper.IamRoleMapper;
import com.baiyue.iam.mapper.IamUserMapper;
import com.baiyue.iam.notification.dto.NotificationDtos.CreateNotificationRequest;
import com.baiyue.iam.notification.dto.NotificationDtos.RecipientType;
import com.baiyue.iam.notification.service.NotificationRecipientResolver;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.test.util.ReflectionTestUtils;

import java.util.List;
import java.util.Map;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.*;

class NotificationRecipientResolverTest {
    private final IamMembershipMapper memberships = mock(IamMembershipMapper.class);
    private final IamUserMapper users = mock(IamUserMapper.class);
    private final IamRoleMapper roles = mock(IamRoleMapper.class);
    private final IamMembershipRoleMapper membershipRoles = mock(IamMembershipRoleMapper.class);
    private final NotificationRecipientResolver resolver = new NotificationRecipientResolver();

    @BeforeEach
    void setup() {
        ReflectionTestUtils.setField(resolver, "memberships", memberships);
        ReflectionTestUtils.setField(resolver, "users", users);
        ReflectionTestUtils.setField(resolver, "roles", roles);
        ReflectionTestUtils.setField(resolver, "membershipRoles", membershipRoles);
    }

    @Test
    void resolvesSpecifiedEnterpriseMemberByUserId() {
        IamMembership membership = new IamMembership();
        membership.setId(301L);
        membership.setTenantId(9L);
        membership.setUserId(2092537408743079938L);
        membership.setStatus("ACTIVE");
        IamUser user = new IamUser();
        user.setId(membership.getUserId());
        user.setDisplayName("测试成员");
        user.setStatus("ACTIVE");
        when(memberships.selectList(any())).thenReturn(List.of(membership));
        when(users.selectById(membership.getUserId())).thenReturn(user);

        var recipients = resolver.resolve(request(RecipientType.USER, List.of(membership.getUserId())));

        assertThat(recipients).containsExactly(new NotificationRecipientResolver.ResolvedRecipient(
                9L, 301L, membership.getUserId(), "测试成员", "MERCHANT"));
    }

    @Test
    void explainsWhenNoActiveRecipientCanBeResolved() {
        when(memberships.selectList(any())).thenReturn(List.of());

        assertThatThrownBy(() -> resolver.resolve(request(RecipientType.USER, List.of(2092537408743079938L))))
                .isInstanceOf(BizException.class)
                .hasMessage("未找到可接收消息的有效成员，请检查用户 ID 和目标企业");
    }

    @Test
    void explainsWhenRoleCodeDoesNotExist() {
        when(roles.selectList(any())).thenReturn(List.of());

        assertThatThrownBy(() -> resolver.resolve(roleRequest(RecipientType.PLATFORM_ROLE, "MISSING_ROLE")))
                .isInstanceOf(BizException.class)
                .hasMessage("角色编码不存在，请检查角色编码是否正确");
    }

    @Test
    void explainsWhenRoleHasNoActiveMembers() {
        IamRole role = new IamRole();
        role.setId(501L);
        when(roles.selectList(any())).thenReturn(List.of(role));
        when(membershipRoles.selectList(any())).thenReturn(List.of());

        assertThatThrownBy(() -> resolver.resolve(roleRequest(RecipientType.PLATFORM_ROLE, "CUSTOMER_REVIEWER")))
                .isInstanceOf(BizException.class)
                .hasMessage("该角色下暂无可接收消息的有效用户，请先为角色分配启用中的成员");
    }

    @Test
    void resolvesEnterpriseMemberAssignedToPlatformProvidedMerchantRole() {
        IamRole role = new IamRole();
        role.setId(501L);
        role.setTenantId(0L);
        role.setAppCode("MERCHANT");
        role.setRoleCode("MERCHANT_OWNER");
        IamMembershipRole assignment = new IamMembershipRole();
        assignment.setTenantId(9L);
        assignment.setRoleId(role.getId());
        assignment.setMembershipId(301L);
        IamMembership membership = new IamMembership();
        membership.setId(301L);
        membership.setTenantId(9L);
        membership.setUserId(401L);
        membership.setStatus("ACTIVE");
        IamUser user = new IamUser();
        user.setId(401L);
        user.setDisplayName("企业管理员");
        user.setStatus("ACTIVE");
        when(roles.selectList(any())).thenReturn(List.of(role));
        when(membershipRoles.selectList(any())).thenReturn(List.of(assignment));
        when(memberships.selectBatchIds(List.of(301L))).thenReturn(List.of(membership));
        when(users.selectById(401L)).thenReturn(user);

        var recipients = resolver.resolve(new CreateNotificationRequest(9L, "ORDER_STATUS_CHANGED",
                RecipientType.TENANT_ROLE, null, "MERCHANT_OWNER", Map.of(), null,
                "notification-tenant-role-key", null, null));

        assertThat(recipients).containsExactly(new NotificationRecipientResolver.ResolvedRecipient(
                9L, 301L, 401L, "企业管理员", "MERCHANT"));
    }

    private CreateNotificationRequest request(RecipientType recipientType, List<Long> recipientIds) {
        return new CreateNotificationRequest(9L, "ORDER_STATUS_CHANGED", recipientType, recipientIds,
                null, Map.of(), null, "notification-test-key", null, null);
    }

    private CreateNotificationRequest roleRequest(RecipientType recipientType, String roleCode) {
        return new CreateNotificationRequest(0L, "ORDER_STATUS_CHANGED", recipientType, null,
                roleCode, Map.of(), null, "notification-role-test-key", null, null);
    }
}