feat(多公司): 第二批 —— 登录带出公司身份、移人仅超管、启动期 DEFAULT 哨兵、列表公司列

company 模块落地(目录读写收窄 + 菜单闸门),并把公司维度接进四个已有出口:
- 登录/current-user 回包带 companyId/companyName,且取名失败不得挡住登录;
- 移人仅超管,且校验「创建人同公司或为超管」不变式(二期免改 77 处过滤点的前提);
- users.company_id 的 DEFAULT 由启动期哨兵盯着,多公司已上线仍未摘则打
  COMPANY_DEFAULT_STILL_PRESENT(ASCII 标记串,供 docker logs grep);
- 账号列表加 company_id/company_name 与可选按公司筛选:超管可筛任意公司,
  公司内 admin 传别家公司视为无结果(不报错也不越权)。

39 例护栏,29 条变异自证(首轮 25/28 咬死,两条存活都是用例侧的洞:
namesByIds 被 mock 掉所以内部去重从未被证明、contains("公司") 分不清闸门与
不变式;修补后 4/4 KILLED)。业务表零 DDL、零回填。
This commit is contained in:
2026-10-04 07:11:13 +08:00
parent 5633898a0d
commit 061147c603
33 changed files with 2454 additions and 12 deletions
@@ -0,0 +1,70 @@
package com.nanri.aiimage.modules.admin;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.modules.admin.controller.AdminUserController;
import com.nanri.aiimage.modules.admin.model.vo.AdminUserItemVo;
import org.junit.jupiter.api.Test;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.web.bind.annotation.RequestParam;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 账号列表的公司列是**跨仓契约**(设计文档 §2.3):Java 侧 `AdminUserItemVo` 出 snake_case,
* Vue 侧 `toAdminUserItem` 只认 `company_id`/`company_name`(见 admin-frontend-vue
* `tests/company-user-list.test.ts` 的反向排他用例)。这里改一个字母,前端不会报错——
* 只会把每一行都显示成 '-'。所以两头都得有闸。
*/
class AdminUserListCompanyContractTest {
@Test
void itemVoSerializesCompanyColumnsInSnakeCase() {
AdminUserItemVo vo = new AdminUserItemVo();
vo.setId(11L);
vo.setUsername("u11");
vo.setRole("normal");
vo.setCompanyId(5L);
vo.setCompanyName("厦门米椿花");
Map<String, Object> json = new ObjectMapper()
.convertValue(vo, new TypeReference<Map<String, Object>>() { });
assertThat(json).containsEntry("company_id", 5L);
assertThat(json).containsEntry("company_name", "厦门米椿花");
}
@Test
void listEndpointTakesCompanyIdAsAnOptionalQueryParamWithoutDefault() throws Exception {
Method list = Arrays.stream(AdminUserController.class.getDeclaredMethods())
.filter(m -> "listUsers".equals(m.getName()))
.findFirst()
.orElseThrow(() -> new AssertionError("AdminUserController 上没有 listUsers 方法"));
Set<RequestParam> params = Arrays.stream(list.getParameters())
.map(p -> AnnotatedElementUtils.findMergedAnnotation(p, RequestParam.class))
.filter(Objects::nonNull)
.collect(Collectors.toSet());
RequestParam companyId = params.stream()
.filter(p -> "company_id".equals(p.name()))
.findFirst()
.orElseThrow(() -> new AssertionError("GET /api/admin/users 没有 company_id 查询参数"));
// required=false 是 §5.3「前端与后端可各自先发」的前提:旧后台不带这个键也要照常返回全部
assertThat(companyId.required()).isFalse();
// 缺省必须真的"没有缺省":写 defaultValue="1" 就变成"默认只查厦门米椿花",筛选框清不掉。
// 拿同为可选无缺省的 role 做参照,比引用 Spring 的内部哨兵常量稳。
RequestParam role = params.stream()
.filter(p -> "role".equals(p.name()))
.findFirst()
.orElseThrow(() -> new AssertionError("参照参数 role 不在了,这条对照失效"));
assertThat(companyId.defaultValue()).isEqualTo(role.defaultValue());
}
}
@@ -0,0 +1,103 @@
package com.nanri.aiimage.modules.admin.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* 后台顶栏的公司身份(设计文档 §2.4 / §1.4):admin-frontend-vue 的
* {@code api/session.ts} 把 {@code /api/admin/current-user} 的 item 原样当 AdminUser 用,
* 没有字段映射层——所以这两个键名必须逐字对上 {@code types/admin.ts} 的
* {@code companyId} / {@code companyName}。
*
* <p>这里拼错一个字母不会报错,只会让顶栏那行公司名永远不显示(前端 {@code || ''} 兜底),
* 所以只能由用例盯着键名,而不是盯着"有没有抛异常"。</p>
*/
class AdminConsoleCurrentUserCompanyTest {
private AdminAuthSupport adminAuthSupport;
private CompanyService companyService;
private AdminConsoleController controller;
private HttpServletRequest request;
private AdminUserEntity operator;
@BeforeEach
void setUp() {
adminAuthSupport = mock(AdminAuthSupport.class);
companyService = mock(CompanyService.class);
controller = new AdminConsoleController(adminAuthSupport, mock(PermissionMenuService.class),
companyService);
request = mock(HttpServletRequest.class);
operator = new AdminUserEntity();
operator.setId(10L);
operator.setUsername("op");
operator.setRole("admin");
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("admin");
}
@SuppressWarnings("unchecked")
private Map<String, Object> item() {
ApiResponse<Map<String, Object>> response = controller.currentUser(request);
return (Map<String, Object>) response.getData().get("item");
}
@Test
@DisplayName("current-user 带 camelCase 的 companyId / companyName")
void currentUserCarriesCompanyIdentityInCamelCase() {
operator.setCompanyId(5L);
when(companyService.nameOrEmpty(5L)).thenReturn("厦门米椿花");
assertThat(item())
.containsEntry("companyId", 5L)
.containsEntry("companyName", "厦门米椿花");
}
@Test
@DisplayName("原有的 id / username / role 一个都不能少")
void keepsTheExistingSelfDescriptionKeys() {
operator.setCompanyId(5L);
when(companyService.nameOrEmpty(5L)).thenReturn("厦门米椿花");
assertThat(item())
.containsEntry("id", 10L)
.containsEntry("username", "op")
.containsEntry("role", "admin");
}
@Test
@DisplayName("没有公司归属的账号:两个键照样写,值为 null / 空串")
void accountWithoutACompanyStillWritesBothKeys() {
operator.setCompanyId(null);
when(companyService.nameOrEmpty(null)).thenReturn("");
assertThat(item())
.containsKeys("companyId", "companyName")
.containsEntry("companyId", null)
.containsEntry("companyName", "");
}
@Test
@DisplayName("公司行查不到时不挡接口:顶栏少一行字,账号还能用后台")
void missingCompanyRowDoesNotBreakCurrentUser() {
operator.setCompanyId(9L);
when(companyService.nameOrEmpty(9L)).thenReturn("");
assertThat(item())
.containsEntry("companyName", "")
.containsEntry("username", "op");
}
}
@@ -0,0 +1,195 @@
package com.nanri.aiimage.modules.admin.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.admin.model.vo.AdminUserItemVo;
import com.nanri.aiimage.modules.admin.model.vo.AdminUserListVo;
import com.nanri.aiimage.modules.admin.spi.UserSecretCleanupPort;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 多公司一期(设计文档 §2.3):账号列表的公司列与「按公司筛选」。
*
* <p>筛选参数的口径是"超管可筛任意公司;公司内 admin 传别家公司 = 无结果"。后者故意不报错也不越权,
* 所以断言必须打在"有没有碰表"上——只断言返回空集合的话,把条件写反(拿别家公司的 id 去查)也是空。</p>
*/
class AdminUserListCompanyTest {
private AdminUserMapper userMapper;
private CompanyService companyService;
private AdminAuthSupport authSupport;
private AdminUserService service;
@BeforeEach
@SuppressWarnings({"unchecked", "rawtypes"})
void setUp() {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), AdminUserEntity.class);
userMapper = mock(AdminUserMapper.class);
companyService = mock(CompanyService.class);
authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionService = mock(PermissionMenuService.class);
service = new AdminUserService(userMapper, mock(WerkzeugPasswordEncoder.class), authSupport,
permissionService, mock(UserSecretCleanupPort.class), companyService);
// 菜单可见性与本组用例无关,全部放开:否则"被 403 挡住"会伪装成"筛选没生效"
when(permissionService.hasAnyAdminMenu(any(), any())).thenReturn(true);
when(userMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(0L);
when(userMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(List.of());
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void superAdminCompanyFilterBecomesAQueryCondition() {
AdminUserEntity operator = operator(1L, "super_admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
service.listUsers(operator, 1, 10, null, null, null, 7L);
LambdaQueryWrapper<AdminUserEntity> query = capturedCountQuery();
assertThat(query.getSqlSegment()).isNotEmpty();
assertThat(query.getParamNameValuePairs()).containsValue(7L);
}
@Test
void superAdminWithoutCompanyFilterAddsNoCondition() {
AdminUserEntity operator = operator(1L, "super_admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
service.listUsers(operator, 1, 10, null, null, null, null);
// 与上一条对照才有意义:不带筛选时查询条件必须一个都没有(不传 != 传 0/传自己公司)
assertThat(capturedCountQuery().getParamNameValuePairs()).isEmpty();
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void adminAskingAnotherCompanyGetsEmptyPageWithoutTouchingTheTable() {
AdminUserEntity operator = operator(10L, "admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("admin");
when(userMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(99L);
AdminUserListVo vo = service.listUsers(operator, 1, 10, null, null, null, 99L);
assertThat(vo.getTotal()).isZero();
assertThat(vo.getItems()).isEmpty();
verify(userMapper, never()).selectCount(any(LambdaQueryWrapper.class));
verify(userMapper, never()).selectList(any(LambdaQueryWrapper.class));
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void adminFilteringItsOwnCompanyBehavesLikeNoFilter() {
AdminUserEntity operator = operator(10L, "admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("admin");
when(userMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(2L);
when(userMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(
List.of(row(11L, 5L), row(12L, 5L)), List.of(), List.of());
AdminUserListVo vo = service.listUsers(operator, 1, 10, null, null, null, 5L);
// 真风险是"自己公司也被判成跨公司"⇒ 整个 admin 的列表恒空。这里必须还是他看得见的那两行。
assertThat(vo.getTotal()).isEqualTo(2L);
assertThat(vo.getItems()).hasSize(2);
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void itemsCarryCompanyIdAndBatchFetchedCompanyName() {
AdminUserEntity operator = operator(1L, "super_admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(userMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(3L);
// 同一次请求里 selectList 被用到三次:分页行 → 创建人行 → 超管的 admin 候选
when(userMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(
List.of(row(11L, 5L), row(12L, 5L), row(13L, 7L)),
List.of(row(1L, 5L)),
List.of());
when(companyService.namesByIds(any())).thenReturn(Map.of(5L, "厦门米椿花", 7L, "福州数富"));
AdminUserListVo vo = service.listUsers(operator, 1, 10, null, null, null, null);
assertThat(vo.getItems()).extracting(AdminUserItemVo::getCompanyId).containsExactly(5L, 5L, 7L);
assertThat(vo.getItems()).extracting(AdminUserItemVo::getCompanyName)
.containsExactly("厦门米椿花", "厦门米椿花", "福州数富");
ArgumentCaptor<Collection<Long>> ids = ArgumentCaptor.forClass((Class) Collection.class);
verify(companyService).namesByIds(ids.capture());
// 三行两个公司 ⇒ 只查一次、且 id 去过重(逐行查就是 N+1)
assertThat(ids.getValue()).containsExactlyInAnyOrder(5L, 7L);
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void rowHangingOnAnUnknownCompanyIsStillListedWithEmptyName() {
AdminUserEntity operator = operator(1L, "super_admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(userMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(1L);
when(userMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(
List.of(row(11L, 404L)), List.of(), List.of());
when(companyService.namesByIds(any())).thenReturn(Map.of());
AdminUserListVo vo = service.listUsers(operator, 1, 10, null, null, null, null);
// 脏数据(账号挂在公司表查不到的 id 上)不能让整页 500;缺名字就空着,前端显示 '-'
assertThat(vo.getItems()).hasSize(1);
assertThat(vo.getItems().get(0).getCompanyId()).isEqualTo(404L);
assertThat(vo.getItems().get(0).getCompanyName()).isEmpty();
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void emptyPageDoesNotAskTheCompanyTableForNames() {
AdminUserEntity operator = operator(1L, "super_admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
service.listUsers(operator, 1, 10, "不存在的关键字", null, null, null);
verify(companyService, never()).namesByIds(any());
}
@SuppressWarnings({"unchecked", "rawtypes"})
private LambdaQueryWrapper<AdminUserEntity> capturedCountQuery() {
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(userMapper).selectCount(captor.capture());
return captor.getValue();
}
private AdminUserEntity row(Long id, Long companyId) {
AdminUserEntity entity = new AdminUserEntity();
entity.setId(id);
entity.setUsername("u" + id);
entity.setRole("normal");
entity.setIsAdmin(0);
entity.setCompanyId(companyId);
return entity;
}
private AdminUserEntity operator(Long id, String role, Long companyId) {
AdminUserEntity operator = new AdminUserEntity();
operator.setId(id);
operator.setUsername("op");
operator.setRole(role);
operator.setIsAdmin("normal".equals(role) ? 0 : 1);
operator.setCompanyId(companyId);
return operator;
}
}
@@ -0,0 +1,231 @@
package com.nanri.aiimage.modules.admin.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.admin.model.dto.AdminUserUpdateRequest;
import com.nanri.aiimage.modules.admin.spi.UserSecretCleanupPort;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 移人(改账号所属公司)的公司边界不变式(设计文档 §2.2 / §6.2)。
*
* <p>要守住的是一条推论:账号被移进 X 公司后,它的 {@code created_by_id} 要么仍是 X 公司的人,
* 要么是超管。这条不变式一旦破口,二期就得回到 77 处 {@code eq(getUserId, userId)} 逐个叠公司边界
* (§7.2),一期"业务代码零改动"的前提就没了。所以断言全部打在真正落库的那条 UPDATE 上。</p>
*/
class AdminUserMoveCompanyTest {
private AdminUserMapper userMapper;
private AdminAuthSupport authSupport;
private CompanyService companyService;
private AdminUserService service;
@BeforeEach
@SuppressWarnings("unchecked")
void setUp() {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), AdminUserEntity.class);
userMapper = mock(AdminUserMapper.class);
WerkzeugPasswordEncoder passwordEncoder = mock(WerkzeugPasswordEncoder.class);
authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionService = mock(PermissionMenuService.class);
companyService = mock(CompanyService.class);
service = new AdminUserService(userMapper, passwordEncoder, authSupport, permissionService,
mock(UserSecretCleanupPort.class), companyService);
when(permissionService.hasAnyAdminMenu(any(), anyList())).thenReturn(true);
when(passwordEncoder.hash(anyString())).thenReturn("hashed");
}
private AdminUserEntity operator(String role, Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId("super_admin".equals(role) ? 1L : 10L);
user.setUsername("op");
user.setRole(role);
user.setIsAdmin("normal".equals(role) ? 0 : 1);
user.setCreatedById(1L);
user.setCompanyId(companyId);
when(authSupport.currentRole(user)).thenReturn(role);
return user;
}
/** 被编辑的账号:normal、挂在 companyId 上、由 createdById 创建。 */
private AdminUserEntity target(Long companyId, Long createdById) {
AdminUserEntity user = new AdminUserEntity();
user.setId(20L);
user.setUsername("moved-user");
user.setRole("normal");
user.setIsAdmin(0);
user.setCompanyId(companyId);
user.setCreatedById(createdById);
when(userMapper.selectById(20L)).thenReturn(user);
return user;
}
private AdminUserEntity creator(Long id, String role, Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setRole(role);
user.setCompanyId(companyId);
when(userMapper.selectById(id)).thenReturn(user);
return user;
}
private AdminUserUpdateRequest moveOnly(Long companyId) {
AdminUserUpdateRequest request = new AdminUserUpdateRequest();
request.setCompanyId(companyId);
return request;
}
@SuppressWarnings({"unchecked", "rawtypes"})
private LambdaUpdateWrapper<AdminUserEntity> capturedUpdate() {
ArgumentCaptor<LambdaUpdateWrapper> captor = ArgumentCaptor.forClass((Class) LambdaUpdateWrapper.class);
verify(userMapper).update(isNull(), captor.capture());
return captor.getValue();
}
/**
* SET 子句才是"这次真的改了哪一列"。LambdaUpdateWrapper 的 getSqlSegment() 只含 WHERE,
* 拿它断言列名会永远假绿。
*/
private String setClause() {
String set = capturedUpdate().getSqlSet();
return set == null ? "" : set;
}
@Test
@DisplayName("只改公司、不改密码/角色/权限,也是合法编辑")
void movingAloneIsAValidEdit() {
AdminUserEntity op = operator("super_admin", 5L);
target(5L, 88L);
creator(88L, "admin", 7L);
assertThatCode(() -> service.updateUser(op, 20L, moveOnly(7L))).doesNotThrowAnyException();
assertThat(setClause()).contains("company_id");
assertThat(capturedUpdate().getParamNameValuePairs().containsValue(7L)).isTrue();
verify(companyService).requireActive(7L);
}
@Test
@DisplayName("创建人在第三家公司:移人必须被拒,且一条 UPDATE 都不发")
void moveIsRefusedWhenTheCreatorLivesInAnotherCompany() {
AdminUserEntity op = operator("super_admin", 5L);
target(5L, 88L);
creator(88L, "admin", 9L);
assertThatThrownBy(() -> service.updateUser(op, 20L, moveOnly(7L)))
.isInstanceOfSatisfying(BusinessException.class, ex -> {
assertThat(ex.getCode()).isEqualTo(403);
// 钉「创建人不变式」这道闸门自己:只写 contains("公司") 的话,
// 移人闸门删掉后由这条接着抛 403,用例照样绿(变异实测栽过)。
assertThat(ex.getMessage()).contains("创建人");
});
verify(userMapper, never()).update(any(), any());
}
@Test
@DisplayName("创建人是超管:不受同公司约束,随便移")
void creatorSuperAdminIsExemptFromTheCompanyMatch() {
AdminUserEntity op = operator("super_admin", 5L);
target(5L, 88L);
creator(88L, "super_admin", 1L);
assertThatCode(() -> service.updateUser(op, 20L, moveOnly(7L))).doesNotThrowAnyException();
assertThat(setClause()).contains("company_id");
}
@Test
@DisplayName("公司内 admin 不许移人:改成别家公司直接 403")
void onlySuperAdminMayMoveAccounts() {
AdminUserEntity op = operator("admin", 5L);
target(5L, op.getId());
creator(op.getId(), "admin", 5L);
assertThatThrownBy(() -> service.updateUser(op, 20L, moveOnly(6L)))
.isInstanceOfSatisfying(BusinessException.class, ex -> {
assertThat(ex.getCode()).isEqualTo(403);
// 必须钉到「移人闸门」这句话:创建人不变式的文案也含「公司」,
// 只断 contains("公司") 时闸门被删掉仍然绿(变异 12 实测存活的原因)。
assertThat(ex.getMessage()).contains("超级管理员");
});
verify(userMapper, never()).update(any(), any());
}
@Test
@DisplayName("admin 传的正好是账号现在这家公司:按「没移」处理,照常改密码")
void namingTheCurrentCompanyIsNotAMove() {
AdminUserEntity op = operator("admin", 5L);
target(5L, op.getId());
creator(op.getId(), "admin", 5L);
AdminUserUpdateRequest request = moveOnly(5L);
request.setPassword("secret9");
service.updateUser(op, 20L, request);
assertThat(setClause()).contains("password_hash");
assertThat(setClause()).doesNotContain("company_id");
}
@Test
@DisplayName("移进去的公司必须存在且启用:先校验再落库")
void destinationCompanyMustExistAndBeActive() {
AdminUserEntity op = operator("super_admin", 5L);
target(5L, 88L);
creator(88L, "admin", 9L);
when(companyService.requireActive(9L)).thenThrow(new BusinessException("公司已停用"));
assertThatThrownBy(() -> service.updateUser(op, 20L, moveOnly(9L)))
.isInstanceOf(BusinessException.class);
verify(userMapper, never()).update(any(), any());
}
@Test
@DisplayName("创建人被删掉了(悬空 created_by_id):无法确认同公司,不移")
void danglingCreatorBlocksTheMove() {
AdminUserEntity op = operator("super_admin", 5L);
target(5L, 88L);
when(userMapper.selectById(88L)).thenReturn(null);
assertThatThrownBy(() -> service.updateUser(op, 20L, moveOnly(7L)))
.isInstanceOf(BusinessException.class);
verify(userMapper, never()).update(any(), any());
}
@Test
@DisplayName("created_by_id 本来就是空的账号:没有冲突可校验,照移")
void nullCreatedByIdMovesWithoutComplaint() {
AdminUserEntity op = operator("super_admin", 5L);
target(5L, null);
assertThatCode(() -> service.updateUser(op, 20L, moveOnly(7L))).doesNotThrowAnyException();
assertThat(setClause()).contains("company_id");
}
}
@@ -0,0 +1,151 @@
package com.nanri.aiimage.modules.admin.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.admin.spi.UserSecretCleanupPort;
import com.nanri.aiimage.modules.admin.model.dto.AdminUserCreateRequest;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
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.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 多公司一期(设计文档 §2.2):建号时账号落进哪家公司,与现有 createdById 规则同构。
*
* <p>断言一律打在 `insert` 捕获到的实体上,而不是打在"有没有抛异常"上。这样把
* `entity.setCompanyId(...)` 删掉,用例必须红(§6.1 的变异自证);若改成断言库里的列
* DEFAULT,删掉那行照样绿——那等于没验。</p>
*/
class AdminUserServiceCompanyTest {
private AdminUserMapper userMapper;
private AdminAuthSupport authSupport;
private CompanyService companyService;
private AdminUserService service;
@BeforeEach
void setUp() {
userMapper = mock(AdminUserMapper.class);
WerkzeugPasswordEncoder passwordEncoder = mock(WerkzeugPasswordEncoder.class);
authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionService = mock(PermissionMenuService.class);
companyService = mock(CompanyService.class);
service = new AdminUserService(userMapper, passwordEncoder, authSupport, permissionService,
mock(UserSecretCleanupPort.class), companyService);
// 菜单可见性与本组用例无关,全部放开:否则"被 403 挡住"会伪装成"公司校验生效"
when(permissionService.hasAnyAdminMenu(any(), any())).thenReturn(true);
when(passwordEncoder.hash(anyString())).thenReturn("hashed");
when(userMapper.insert(any(AdminUserEntity.class))).thenAnswer(invocation -> {
invocation.<AdminUserEntity>getArgument(0).setId(20L);
return 1;
});
}
@Test
void superAdminPlacesNewUserInSpecifiedCompany() {
AdminUserEntity operator = operator(1L, "super_admin", 1L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
AdminUserCreateRequest request = request(7L);
service.createUser(operator, request);
assertThat(insertedCompany()).isEqualTo(7L);
verify(companyService).requireActive(7L);
}
@Test
void superAdminWithoutCompanyFallsBackToItsOwnCompany() {
// 操作者所属公司故意取 3:实现里写死 1(照抄列 DEFAULT)必须被这条抓到
AdminUserEntity operator = operator(1L, "super_admin", 3L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
service.createUser(operator, request(null));
assertThat(insertedCompany()).isEqualTo(3L);
}
@Test
void adminWithoutCompanyFallsBackToItsOwnCompany() {
AdminUserEntity operator = operator(10L, "admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("admin");
service.createUser(operator, request(null));
assertThat(insertedCompany()).isEqualTo(5L);
}
@Test
void adminMayNameItsOwnCompanyExplicitly() {
AdminUserEntity operator = operator(10L, "admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("admin");
service.createUser(operator, request(5L));
assertThat(insertedCompany()).isEqualTo(5L);
}
@Test
void adminCannotPlaceNewUserInAnotherCompany() {
AdminUserEntity operator = operator(10L, "admin", 5L);
when(authSupport.currentRole(operator)).thenReturn("admin");
assertThatThrownBy(() -> service.createUser(operator, request(6L)))
.isInstanceOfSatisfying(BusinessException.class, ex -> {
assertThat(ex.getCode()).isEqualTo(403);
// 排他:必须是被公司边界挡下,而不是菜单/角色那两条 403
assertThat(ex.getMessage()).contains("公司");
});
verify(userMapper, never()).insert(any(AdminUserEntity.class));
}
@Test
void companyExistenceIsCheckedBeforeTheRowIsInserted() {
AdminUserEntity operator = operator(1L, "super_admin", 1L);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(companyService.requireActive(9L)).thenThrow(new BusinessException("公司不存在"));
assertThatThrownBy(() -> service.createUser(operator, request(9L)))
.isInstanceOf(BusinessException.class);
// 先校验后插入:反过来就会留下一条挂在不存在公司上的账号
verify(userMapper, never()).insert(any(AdminUserEntity.class));
}
private AdminUserCreateRequest request(Long companyId) {
AdminUserCreateRequest request = new AdminUserCreateRequest();
request.setUsername("created-user");
request.setPassword("secret1");
request.setRole("normal");
request.setCompanyId(companyId);
return request;
}
private AdminUserEntity operator(Long id, String role, Long companyId) {
AdminUserEntity operator = new AdminUserEntity();
operator.setId(id);
operator.setUsername("op");
operator.setRole(role);
operator.setIsAdmin("normal".equals(role) ? 0 : 1);
operator.setCreatedById(1L);
operator.setCompanyId(companyId);
return operator;
}
private Long insertedCompany() {
ArgumentCaptor<AdminUserEntity> captor = ArgumentCaptor.forClass(AdminUserEntity.class);
verify(userMapper).insert(captor.capture());
return captor.getValue().getCompanyId();
}
}
@@ -5,6 +5,7 @@ import com.nanri.aiimage.modules.admin.model.dto.AdminUserCreateRequest;
import com.nanri.aiimage.modules.admin.model.dto.AdminUserUpdateRequest;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
@@ -37,7 +38,8 @@ class AdminUserServiceTest {
PermissionMenuService permissionService = mock(PermissionMenuService.class);
UserApiSecretService userApiSecretService = mock(UserApiSecretService.class);
AdminUserService service = new AdminUserService(
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService);
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService,
mock(CompanyService.class));
AdminUserEntity operator = user(10L, "admin", 1, null);
AdminUserCreateRequest request = new AdminUserCreateRequest();
request.setUsername("created-user");
@@ -83,7 +85,8 @@ class AdminUserServiceTest {
PermissionMenuService permissionService = mock(PermissionMenuService.class);
UserApiSecretService userApiSecretService = mock(UserApiSecretService.class);
AdminUserService service = new AdminUserService(
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService);
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService,
mock(CompanyService.class));
AdminUserEntity operator = user(10L, "admin", 1, null);
AdminUserEntity target = user(20L, "normal", 0, 10L);
AdminUserUpdateRequest request = new AdminUserUpdateRequest();
@@ -123,7 +126,8 @@ class AdminUserServiceTest {
PermissionMenuService permissionService = mock(PermissionMenuService.class);
UserApiSecretService userApiSecretService = mock(UserApiSecretService.class);
AdminUserService service = new AdminUserService(
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService);
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService,
mock(CompanyService.class));
AdminUserEntity operator = user(10L, "admin", 1, null);
AdminUserEntity target = user(20L, "normal", 0, 10L);
@@ -150,7 +154,8 @@ class AdminUserServiceTest {
PermissionMenuService permissionService = mock(PermissionMenuService.class);
UserApiSecretService userApiSecretService = mock(UserApiSecretService.class);
AdminUserService service = new AdminUserService(
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService);
userMapper, passwordEncoder, authSupport, permissionService, userApiSecretService,
mock(CompanyService.class));
AdminUserEntity operator = user(10L, "admin", 1, null);
AdminUserEntity target = user(20L, "normal", 0, 10L);
@@ -0,0 +1,146 @@
package com.nanri.aiimage.modules.auth.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AuthProperties;
import com.nanri.aiimage.common.security.JwtService;
import com.nanri.aiimage.modules.auth.mapper.LoginUserMapper;
import com.nanri.aiimage.modules.auth.model.dto.LoginRequest;
import com.nanri.aiimage.modules.auth.model.entity.LoginUserEntity;
import com.nanri.aiimage.modules.auth.model.vo.LoginResultVo;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import io.jsonwebtoken.Claims;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 用户端(app-web)登录回包里的公司身份(设计文档 §2.4)。
*
* <p>前端 {@code src/shared/auth/company-identity.ts} 读的是 {@code data.companyName},
* 拿到空串就清 localStorage 键。所以这里要保证两件事:① 有公司时名字带得出去;
* ② <b>公司这一环永远不能把登录本身弄失败</b>——公司查不到、公司停用、账号压根没有公司,
* 都只能让公司名变空。②用一条"把 requireActive 桩成必抛"的用例钉住:
* 谁把显示口径改成准入口径,这条立刻红。</p>
*/
class AuthServiceCompanyTest {
private LoginUserMapper loginUserMapper;
private WerkzeugPasswordEncoder passwordEncoder;
private JwtService jwtService;
private CompanyService companyService;
private AuthService service;
@BeforeEach
void setUp() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
LoginUserEntity.class);
loginUserMapper = mock(LoginUserMapper.class);
passwordEncoder = mock(WerkzeugPasswordEncoder.class);
jwtService = mock(JwtService.class);
companyService = mock(CompanyService.class);
AuthProperties authProperties = mock(AuthProperties.class);
// 本组用例只关心公司身份,单设备互踢那条路径留给 AuthServiceTest
when(authProperties.isSingleDeviceEnabled()).thenReturn(false);
when(jwtService.ttlSeconds()).thenReturn(604800L);
service = new AuthService(loginUserMapper, passwordEncoder, jwtService,
mock(PermissionMenuService.class), authProperties, companyService);
}
private LoginUserEntity user(Long companyId) {
LoginUserEntity user = new LoginUserEntity();
user.setId(7L);
user.setUsername("u7");
user.setPasswordHash("hash");
user.setIsAdmin(0);
user.setRole("normal");
user.setCompanyId(companyId);
user.setMachine("devA");
return user;
}
private LoginRequest loginRequest() {
LoginRequest request = new LoginRequest();
request.setUsername("u7");
request.setPassword("pwd");
request.setDeviceId("devA");
return request;
}
private void stubSuccessfulLogin(LoginUserEntity user) {
when(loginUserMapper.selectOne(any())).thenReturn(user);
when(passwordEncoder.matches("pwd", "hash")).thenReturn(true);
when(jwtService.issue(eq(7L), anyString(), anyString())).thenReturn("jwt-token");
}
@Test
@DisplayName("登录回包带 companyId 与公司名")
void loginCarriesCompanyIdentity() {
stubSuccessfulLogin(user(5L));
when(companyService.nameOrEmpty(5L)).thenReturn("厦门米椿花");
LoginResultVo vo = service.login(loginRequest());
assertThat(vo.getCompanyId()).isEqualTo(5L);
assertThat(vo.getCompanyName()).isEqualTo("厦门米椿花");
}
@Test
@DisplayName("公司行查不到:登录照样成功,只是公司名为空")
void loginSucceedsWhenTheCompanyRowIsGone() {
stubSuccessfulLogin(user(9L));
when(companyService.nameOrEmpty(9L)).thenReturn("");
// 实现一旦改成"登录要校验公司可用"(requireActive),这条立刻红:
// 停用一家公司就等于把它的账号全部锁在门外。
when(companyService.requireActive(any())).thenThrow(new BusinessException("公司已停用"));
LoginResultVo vo = service.login(loginRequest());
assertThat(vo.getToken()).isEqualTo("jwt-token");
assertThat(vo.getCompanyName()).isEmpty();
verify(companyService, never()).requireActive(any());
}
@Test
@DisplayName("账号没有公司归属:companyId 为 null、公司名为空串,不是 null 字符串")
void userWithoutACompanyLogsInWithEmptyCompanyName() {
stubSuccessfulLogin(user(null));
when(companyService.nameOrEmpty(null)).thenReturn("");
LoginResultVo vo = service.login(loginRequest());
assertThat(vo.getCompanyId()).isNull();
assertThat(vo.getCompanyName()).isEmpty();
}
@Test
@DisplayName("check_login 同样带公司身份:刷新页面后顶栏不能空")
void checkLoginCarriesCompanyIdentity() {
LoginUserEntity user = user(5L);
Claims claims = mock(Claims.class);
when(claims.getSubject()).thenReturn("7");
when(claims.get("deviceId")).thenReturn("devA");
when(jwtService.parse("t")).thenReturn(claims);
when(loginUserMapper.selectById(7L)).thenReturn(user);
when(jwtService.issue(eq(7L), anyString(), anyString())).thenReturn("jwt-token");
when(companyService.nameOrEmpty(5L)).thenReturn("厦门米椿花");
LoginResultVo vo = service.checkLogin("t", null);
assertThat(vo.getCompanyId()).isEqualTo(5L);
assertThat(vo.getCompanyName()).isEqualTo("厦门米椿花");
}
}
@@ -9,6 +9,7 @@ import com.nanri.aiimage.modules.auth.model.dto.LoginRequest;
import com.nanri.aiimage.modules.auth.model.entity.LoginUserEntity;
import com.nanri.aiimage.modules.auth.model.vo.LoginResultVo;
import com.nanri.aiimage.modules.auth.util.WerkzeugPasswordEncoder;
import com.nanri.aiimage.modules.company.service.CompanyService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import io.jsonwebtoken.Claims;
import org.apache.ibatis.builder.MapperBuilderAssistant;
@@ -157,7 +158,7 @@ class AuthServiceTest {
when(authProperties.isSingleDeviceEnabled()).thenReturn(singleDeviceEnabled);
when(jwtService.ttlSeconds()).thenReturn(604800L);
AuthService service = new AuthService(loginUserMapper, passwordEncoder, jwtService,
permissionMenuService, authProperties);
permissionMenuService, authProperties, mock(CompanyService.class));
return new Fixture(service, loginUserMapper, passwordEncoder, jwtService);
}
@@ -0,0 +1,41 @@
package com.nanri.aiimage.modules.company;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.Test;
import java.util.Map;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 多公司一期:`company` 是本仓第一个真正的租户表,实体一旦映射错(表名拼错、列名对不上 V143),
* 报错发生在运行期第一次调用上,本地 mvn 全绿也拦不住。这例把实体与 V143 的表结构对齐。
*/
class CompanyEntityMappingTest {
@Test
void companyEntityMapsToV143CompanyTableColumns() {
TableInfo tableInfo = TableInfoHelper.getTableInfo(CompanyEntity.class);
if (tableInfo == null) {
tableInfo = TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), CompanyEntity.class);
}
assertThat(tableInfo.getTableName())
.as("必须映射 V143 建的那张 company 表")
.isEqualTo("company");
Map<String, String> columnByProperty = tableInfo.getFieldList().stream()
.collect(Collectors.toMap(TableFieldInfo::getProperty, TableFieldInfo::getColumn, (a, b) -> a));
assertThat(columnByProperty)
.as("实体列名必须与 V143 的 company 表逐字一致")
.containsEntry("companyName", "company_name")
.containsEntry("status", "status")
.containsEntry("remark", "remark");
}
}
@@ -0,0 +1,54 @@
package com.nanri.aiimage.modules.company;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.auth.model.entity.LoginUserEntity;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 多公司一期(设计文档 §1.5):`users` 被两个实体同时映射,加 company_id 时漏改任意一处,
* 后果是半边链路(后台用户管理 / 登录)静默读不到所属公司,不报错、不失败。
* 这两例把「两处都要有这一列」钉住。
*
* <p>断言打在 MyBatis-Plus 实际解析出的列名上,而不是打在注解字符串上:
* 写成 `@TableField("companyid")` 这类拼错也必须红,而只靠驼峰推导映射正确的实现同样绿。</p>
*/
class UsersCompanyIdMappingTest {
@Test
void adminUserEntityResolvesCompanyIdToCompanyIdColumn() {
assertThat(columnOf(AdminUserEntity.class, "companyId"))
.as("AdminUserEntity(后台用户管理用的 users 映射)必须有 companyId → company_id")
.isEqualTo("company_id");
}
@Test
void loginUserEntityResolvesCompanyIdToCompanyIdColumn() {
assertThat(columnOf(LoginUserEntity.class, "companyId"))
.as("LoginUserEntity(登录链路用的 users 映射)必须有 companyId → company_id")
.isEqualTo("company_id");
}
/** 属性不存在时返回 null(用例红),而不是反射抛 NoSuchFieldException——失败信息要说清是哪个实体少了列。 */
private static String columnOf(Class<?> entityType, String property) {
TableInfo tableInfo = TableInfoHelper.getTableInfo(entityType);
if (tableInfo == null) {
tableInfo = TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), entityType);
}
assertThat(tableInfo.getTableName())
.as(entityType.getSimpleName() + " 必须仍映射 users 表")
.isEqualTo("users");
return tableInfo.getFieldList().stream()
.filter(field -> property.equals(field.getProperty()))
.map(TableFieldInfo::getColumn)
.findFirst()
.orElse(null);
}
}
@@ -0,0 +1,152 @@
package com.nanri.aiimage.modules.company.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.model.dto.CompanySaveRequest;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.company.model.vo.CompanyVo;
import com.nanri.aiimage.modules.company.service.CompanyService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.InOrder;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* 公司目录端点的对外契约(设计文档 §2.3)。
*
* <p>钉的是 admin-frontend-vue/src/api/companies.ts 实际会打的三个地址,以及"先鉴权、
* 再碰目录"的顺序。路径写错时前端只会拿到空列表、不报错,所以只能由用例盯着。</p>
*/
class CompanyControllerEndpointTest {
private AdminAuthSupport adminAuthSupport;
private CompanyService companyService;
private CompanyController controller;
private HttpServletRequest request;
private AdminUserEntity operator;
private CompanySaveRequest body;
@BeforeEach
void setUp() {
adminAuthSupport = mock(AdminAuthSupport.class);
companyService = mock(CompanyService.class);
controller = new CompanyController(adminAuthSupport, companyService);
request = mock(HttpServletRequest.class);
operator = new AdminUserEntity();
operator.setId(1L);
operator.setCompanyId(1L);
body = new CompanySaveRequest();
body.setCompanyName("福州数富");
body.setStatus(CompanyService.STATUS_ACTIVE);
body.setRemark("二期");
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(operator);
when(companyService.listVisible(operator)).thenReturn(List.of(company(1L, "厦门米椿花")));
when(companyService.create(any(), any())).thenReturn(company(2L, "福州数富"));
when(companyService.update(any(), any(), any())).thenReturn(company(2L, "福州数富科技"));
}
private CompanyEntity company(Long id, String name) {
CompanyEntity entity = new CompanyEntity();
entity.setId(id);
entity.setCompanyName(name);
entity.setStatus(CompanyService.STATUS_ACTIVE);
return entity;
}
@Test
@DisplayName("每个端点先鉴权再进 service,顺序不能反")
void everyEndpointAuthenticatesBeforeTouchingTheDirectory() {
controller.listCompanies(request);
controller.createCompany(request, body);
controller.updateCompany(request, 2L, body);
InOrder order = inOrder(adminAuthSupport, companyService);
order.verify(adminAuthSupport).requireAdminOrInternal(request);
order.verify(companyService).listVisible(operator);
order.verify(adminAuthSupport).requireAdminOrInternal(request);
order.verify(companyService).create(operator, body);
order.verify(adminAuthSupport).requireAdminOrInternal(request);
order.verify(companyService).update(operator, 2L, body);
}
@Test
@DisplayName("挂在 /api/admin 前缀下,路径与前端 companies.ts 逐字一致")
void routesMatchWhatTheAdminConsoleCalls() {
assertThat(rootPaths()).contains("/api/admin");
assertThat(pathsOf("listCompanies")).contains("/companies");
assertThat(pathsOf("createCompany")).contains("/companies");
assertThat(pathsOf("updateCompany")).contains("/companies/{id}");
}
@Test
@DisplayName("不提供删除公司的端点:账号挂着的公司删不掉,只能停用")
void exposesNoDeleteEndpoint() {
for (Method method : CompanyController.class.getDeclaredMethods()) {
assertThat(AnnotatedElementUtils.findMergedAnnotation(method, DeleteMapping.class))
.as("方法 %s 不该是 DELETE", method.getName())
.isNull();
}
}
@Test
@DisplayName("列表回包是 CompanyVo 而不是实体:实体字段是 camelCase,前端解析不到公司名")
void listReturnsVoItemsNotEntities() {
ApiResponse<List<CompanyVo>> response = controller.listCompanies(request);
assertThat(response.getData()).hasSize(1);
assertThat(response.getData().get(0).getCompanyName()).isEqualTo("厦门米椿花");
}
@Test
@DisplayName("新建/改名把落库后的那一条回给前端,省一次重新拉列表")
void writeEndpointsReturnTheSavedCompany() {
assertThat(controller.createCompany(request, body).getData().getId()).isEqualTo(2L);
assertThat(controller.updateCompany(request, 2L, body).getData().getCompanyName())
.isEqualTo("福州数富科技");
}
/**
* GetMapping/PostMapping/PutMapping 都是 @RequestMapping 的派生注解,
* findMergedAnnotation 会顺着元注解找到并把 path/value 归一(@AliasFor 只在合成注解上生效,
* 所以不能直接 getAnnotation(...).path(),那会读到没被别名填上的空数组)。
*/
private List<String> pathsOf(String methodName) {
for (Method method : CompanyController.class.getDeclaredMethods()) {
if (method.getName().equals(methodName)) {
RequestMapping mapping = AnnotatedElementUtils.findMergedAnnotation(method, RequestMapping.class);
assertThat(mapping).as("方法 %s 上没有 HTTP 映射注解", methodName).isNotNull();
return collect(mapping);
}
}
throw new AssertionError("找不到端点方法:" + methodName);
}
private List<String> rootPaths() {
RequestMapping mapping = AnnotatedElementUtils.findMergedAnnotation(CompanyController.class, RequestMapping.class);
assertThat(mapping).isNotNull();
return collect(mapping);
}
private List<String> collect(RequestMapping mapping) {
List<String> paths = new ArrayList<>(Arrays.asList(mapping.value()));
paths.addAll(Arrays.asList(mapping.path()));
return paths;
}
}
@@ -0,0 +1,45 @@
package com.nanri.aiimage.modules.company.model.vo;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.time.LocalDateTime;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
/**
* CompanyVo 的线上字段名 = admin-frontend-vue/src/api/companies-model.ts 的读法。
*
* <p>前端那条用例只能证明"前端按 company_name 解析",证明不了后端发的是不是这个名字;
* 两边都在、且各测各的,才是这条跨产物契约唯一的实跑闸。</p>
*/
class CompanyVoTest {
@Test
@DisplayName("序列化成 snake_case,时间按 'yyyy-MM-dd HH:mm' 出字符串")
void serializesWithTheColumnNamesTheConsoleParses() throws Exception {
CompanyEntity entity = new CompanyEntity();
entity.setId(2L);
entity.setCompanyName("福州数富");
entity.setStatus(0);
entity.setRemark("改名并停用");
entity.setCreatedAt(LocalDateTime.of(2026, 10, 4, 14, 5));
ObjectMapper mapper = new ObjectMapper();
Map<String, Object> json = mapper.readValue(
mapper.writeValueAsString(CompanyVo.from(entity)),
new TypeReference<Map<String, Object>>() {
});
assertThat(json.keySet()).containsExactlyInAnyOrder(
"id", "company_name", "status", "remark", "created_at", "updated_at");
assertThat(json.get("company_name")).isEqualTo("福州数富");
assertThat(json.get("created_at")).isEqualTo("2026-10-04 14:05");
// 库里没读到的时间给空串:前端 formatDateTime 才有占位,不会渲染出 undefined
assertThat(json.get("updated_at")).isEqualTo("");
}
}
@@ -0,0 +1,170 @@
package com.nanri.aiimage.modules.company.service;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.jdbc.core.JdbcTemplate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 「半套发布」哨兵(设计文档 §6.3)。
*
* <p>{@code users.company_id DEFAULT 1} 只为发布期的旧 jar 存在(§8.2)。第二家公司一旦开通而 DEFAULT
* 还没摘,此后每个没显式传公司的建号都会被静默塞进默认那家——不报错、不丢数据,只在后台列表里
* 表现成"这个人怎么在别家公司"。所以必须用代码在启动期喊出来,而不是写在注释里等人记得。</p>
*/
class CompanyDefaultGuardTest {
private CompanyMapper companyMapper;
private JdbcTemplate jdbcTemplate;
private CompanyDefaultGuard guard;
private ListAppender<ILoggingEvent> appender;
@BeforeEach
void setUp() {
companyMapper = mock(CompanyMapper.class);
jdbcTemplate = mock(JdbcTemplate.class);
guard = new CompanyDefaultGuard(companyMapper, jdbcTemplate);
Logger logger = (Logger) LoggerFactory.getLogger(CompanyDefaultGuard.class);
appender = new ListAppender<>();
appender.setContext(logger.getLoggerContext());
appender.start();
logger.addAppender(appender);
}
@AfterEach
void tearDown() {
((Logger) LoggerFactory.getLogger(CompanyDefaultGuard.class)).detachAppender(appender);
appender.stop();
}
private void companies(long count) {
when(companyMapper.selectCount(null)).thenReturn(count);
}
private void columnDefault(String value) {
when(jdbcTemplate.queryForObject(anyString(), eq(String.class))).thenReturn(value);
}
private String messageAt(Level level) {
return appender.list.stream()
.filter(e -> e.getLevel() == level)
.map(ILoggingEvent::getFormattedMessage)
.findFirst()
.orElse("");
}
@Test
@DisplayName("第二家公司已开通、DEFAULT 还在:打 ERROR 并带上哨兵标记")
void secondCompanyWithDefaultStillOnShoutsError() {
companies(2);
columnDefault("1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("2");
}
@Test
@DisplayName("只有一家公司:DEFAULT 是发布期故意留的,不许报警")
void singleCompanyKeepsQuiet() {
companies(1);
columnDefault("1");
guard.check();
assertThat(messageAt(Level.ERROR)).isEmpty();
}
@Test
@DisplayName("DEFAULT 已经摘掉:一声不响")
void droppedDefaultKeepsQuiet() {
companies(3);
columnDefault(null);
guard.check();
assertThat(messageAt(Level.ERROR)).isEmpty();
}
@Test
@DisplayName("DEFAULT 是空串也按「已摘除」处理,别把空值读成还在")
void blankDefaultCountsAsDropped() {
companies(2);
columnDefault(" ");
guard.check();
assertThat(messageAt(Level.ERROR)).isEmpty();
}
@Test
@DisplayName("查不到一家公司:没到多公司阶段,不猜也不报")
void noCompanyAtAllKeepsQuiet() {
companies(0);
guard.check();
assertThat(messageAt(Level.ERROR)).isEmpty();
verify(jdbcTemplate, org.mockito.Mockito.never()).queryForObject(anyString(), eq(String.class));
}
@Test
@DisplayName("探针本身失败:不许静默——降级成 WARN 说明哨兵没跑成")
void probeFailureIsAnnouncedNotSwallowed() {
when(companyMapper.selectCount(null)).thenThrow(new RuntimeException("没有 information_schema 读权限"));
guard.check();
assertThat(messageAt(Level.ERROR)).isEmpty();
assertThat(messageAt(Level.WARN))
.contains(CompanyDefaultGuard.PROBE_FAILED)
.contains("没有 information_schema 读权限");
}
@Test
@DisplayName("探的是 users.company_id 这一列,表名列名写错就等于没探")
void probeReadsTheRightColumn() {
companies(2);
columnDefault("1");
guard.check();
ArgumentCaptor<String> sql = ArgumentCaptor.forClass(String.class);
verify(jdbcTemplate).queryForObject(sql.capture(), eq(String.class));
assertThat(sql.getValue())
.contains("information_schema.COLUMNS")
.contains("DATABASE()")
.contains("'users'")
.contains("'company_id'");
}
@Test
@DisplayName("哨兵挂在 ApplicationReadyEvent 上:漏了这个注解它就永远不跑")
void guardRunsWhenTheApplicationIsReady() throws NoSuchMethodException {
EventListener listener = CompanyDefaultGuard.class
.getDeclaredMethod("checkOnStartup")
.getAnnotation(EventListener.class);
assertThat(listener).isNotNull();
assertThat(listener.value()).containsExactly(ApplicationReadyEvent.class);
}
}
@@ -0,0 +1,299 @@
package com.nanri.aiimage.modules.company.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.dto.CompanySaveRequest;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.util.List;
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.ArgumentMatchers.anyList;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 公司目录(设计文档 §2.3)的可见范围与写入边界。
*
* <p>读口径与写口径必须一起收窄:只把写拦成超管、列表仍返回全部公司,等于把别家公司的
* 名字泄露给本公司管理员。</p>
*/
class CompanyServiceDirectoryTest {
private CompanyMapper companyMapper;
private AdminAuthSupport adminAuthSupport;
private PermissionMenuService permissionMenuService;
private CompanyService companyService;
@BeforeEach
void setUp() {
// LambdaQueryWrapper 的列名解析依赖 TableInfo 缓存,单测没有 Spring 上下文,手工钉一次。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), CompanyEntity.class);
companyMapper = mock(CompanyMapper.class);
adminAuthSupport = mock(AdminAuthSupport.class);
permissionMenuService = mock(PermissionMenuService.class);
when(permissionMenuService.hasAnyAdminMenu(any(), anyList())).thenReturn(true);
companyService = new CompanyService(companyMapper, adminAuthSupport, permissionMenuService);
}
private AdminUserEntity operator(String role, Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(100L);
user.setUsername("op");
user.setRole(role);
user.setCompanyId(companyId);
when(adminAuthSupport.currentRole(user)).thenReturn(role);
return user;
}
private CompanyEntity company(long id, String name, int status) {
CompanyEntity entity = new CompanyEntity();
entity.setId(id);
entity.setCompanyName(name);
entity.setStatus(status);
return entity;
}
private CompanySaveRequest request(String name, Integer status, String remark) {
CompanySaveRequest req = new CompanySaveRequest();
req.setCompanyName(name);
req.setStatus(status);
req.setRemark(remark);
return req;
}
@SuppressWarnings("unchecked")
private LambdaQueryWrapper<CompanyEntity> capturedSelectList() {
ArgumentCaptor<LambdaQueryWrapper<CompanyEntity>> captor =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(companyMapper).selectList(captor.capture());
return materialize(captor.getValue());
}
@SuppressWarnings("unchecked")
private LambdaQueryWrapper<CompanyEntity> capturedSelectCount() {
ArgumentCaptor<LambdaQueryWrapper<CompanyEntity>> captor =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(companyMapper).selectCount(captor.capture());
return materialize(captor.getValue());
}
/**
* MP 的 paramNameValuePairs 要把条件渲染进 sqlSegment 才落值,所以读参数前先摸一次
* getSqlSegment()(仓库里 DedupeTotalDataServiceTest 同样这么绕)。
*/
private LambdaQueryWrapper<CompanyEntity> materialize(LambdaQueryWrapper<CompanyEntity> query) {
assertThat(query.getSqlSegment()).isNotNull();
return query;
}
/**
* 断言的是"有没有带值的查询条件",不是某个列名。
*
* <p>不要写成 contains("company_id"):company 表压根没有这一列(它是主表,自己的主键叫 id),
* 那样写无论实现怎么做都恒绿。MP 只在 eq/in/like 这类带值条件里往 paramNameValuePairs
* 塞参数,orderBy 不塞,所以"超管为空、管理员恰好是自己公司"是能咬住实现的读法。</p>
*/
@Test
@DisplayName("超管的公司目录不带任何过滤条件")
void superAdminDirectoryHasNoCompanyFilter() {
when(companyMapper.selectList(any())).thenReturn(List.of(company(1, "厦门米椿花", 1), company(2, "福州数富", 1)));
List<CompanyEntity> visible = companyService.listVisible(operator("super_admin", 1L));
assertThat(visible).hasSize(2);
assertThat(capturedSelectList().getParamNameValuePairs()).isEmpty();
}
@Test
@DisplayName("公司内管理员的目录只查自己公司:读口径必须跟写口径一起收窄")
void companyScopedAdminDirectoryIsFilteredToOwnCompany() {
when(companyMapper.selectList(any())).thenReturn(List.of(company(2, "福州数富", 1)));
List<CompanyEntity> visible = companyService.listVisible(operator("admin", 2L));
assertThat(visible).hasSize(1);
LambdaQueryWrapper<CompanyEntity> query = capturedSelectList();
assertThat(query.getSqlSegment()).contains("id");
assertThat(query.getParamNameValuePairs()).containsValue(2L);
}
@Test
@DisplayName("非管理员账号一律拒绝读目录(不能只靠 controller 的菜单门)")
void nonAdminCallerIsRejected() {
assertThatThrownBy(() -> companyService.listVisible(operator(null, 2L)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("管理员");
verify(companyMapper, never()).selectList(any());
}
@Test
@DisplayName("管理员没有公司归属时直接拒绝,而不是退化成看到全部公司")
void adminWithoutCompanyIsRejectedInsteadOfSeeingEverything() {
assertThatThrownBy(() -> companyService.listVisible(operator("admin", null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("公司");
verify(companyMapper, never()).selectList(any());
}
@Test
@DisplayName("没有被授予 admin_companies 菜单的人一律 403")
void callerWithoutCompanyMenuIsRejected() {
when(permissionMenuService.hasAnyAdminMenu(any(), anyList())).thenReturn(false);
assertThatThrownBy(() -> companyService.listVisible(operator("admin", 2L)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("公司");
verify(companyMapper, never()).selectList(any());
}
@Test
@DisplayName("新增公司仅超管:公司内管理员即使拿到菜单也不能建第二家公司")
void companyAdminCannotCreate() {
assertThatThrownBy(() -> companyService.create(operator("admin", 2L), request("福州数富", null, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("超级管理员");
verify(companyMapper, never()).insert(any(CompanyEntity.class));
}
@Test
@DisplayName("超管新建公司:名称去空格,未指定状态时落启用")
void superAdminCreateTrimsNameAndActivates() {
when(companyMapper.selectCount(any())).thenReturn(0L);
companyService.create(operator("super_admin", 1L), request(" 福州数富 ", null, " 二期 "));
ArgumentCaptor<CompanyEntity> captor = ArgumentCaptor.forClass(CompanyEntity.class);
verify(companyMapper).insert(captor.capture());
assertThat(captor.getValue().getCompanyName()).isEqualTo("福州数富");
assertThat(captor.getValue().getStatus()).isEqualTo(CompanyService.STATUS_ACTIVE);
assertThat(captor.getValue().getRemark()).isEqualTo("二期");
// 查重必须拿 trim 后的名字去比,否则 " 厦门米椿花" 会绕过 uk_company_name 建成第二家长得一样的公司
assertThat(capturedSelectCount().getParamNameValuePairs()).containsValue("福州数富");
}
@Test
@DisplayName("公司名超过列宽 128 时先拒,别把 1406 抛成 500")
void createRejectsNameLongerThanColumn() {
assertThatThrownBy(() -> companyService.create(
operator("super_admin", 1L), request("长".repeat(129), null, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("128");
verify(companyMapper, never()).insert(any(CompanyEntity.class));
}
@Test
@DisplayName("备注超过列宽 255 时先拒")
void createRejectsRemarkLongerThanColumn() {
assertThatThrownBy(() -> companyService.create(
operator("super_admin", 1L), request("福州数富", null, "备".repeat(256))))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("备注");
verify(companyMapper, never()).insert(any(CompanyEntity.class));
}
@Test
@DisplayName("公司名空白一律拒绝(company_name 是 NOT NULL + 唯一索引)")
void createRejectsBlankName() {
assertThatThrownBy(() -> companyService.create(operator("super_admin", 1L), request(" ", null, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("不能为空");
verify(companyMapper, never()).insert(any(CompanyEntity.class));
}
@Test
@DisplayName("重名公司在写库前就被拒(uk_company_name 只能兜底,不能当校验用)")
void createRejectsDuplicateName() {
when(companyMapper.selectCount(any())).thenReturn(1L);
assertThatThrownBy(() -> companyService.create(operator("super_admin", 1L), request("厦门米椿花", null, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("已存在");
verify(companyMapper, never()).insert(any(CompanyEntity.class));
}
@Test
@DisplayName("状态只认 0/1,别的值不写进 tinyint 列")
void createRejectsStatusOutsideZeroAndOne() {
assertThatThrownBy(() -> companyService.create(operator("super_admin", 1L), request("福州数富", 5, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("状态");
verify(companyMapper, never()).insert(any(CompanyEntity.class));
}
@Test
@DisplayName("改名/启停仅超管")
void companyAdminCannotUpdate() {
assertThatThrownBy(() -> companyService.update(operator("admin", 2L), 1L, request("厦门米椿花", 0, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("超级管理员");
verify(companyMapper, never()).updateById(any(CompanyEntity.class));
}
@Test
@DisplayName("改一家不存在的公司是失败的,不能静默新建")
void updateRejectsUnknownCompany() {
when(companyMapper.selectById(9L)).thenReturn(null);
assertThatThrownBy(() -> companyService.update(operator("super_admin", 1L), 9L, request("福州数富", 1, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("不存在");
verify(companyMapper, never()).updateById(any(CompanyEntity.class));
}
@Test
@DisplayName("改成别家公司已有的名字被拒(唯一性排除自己)")
void updateRejectsNameTakenByAnotherCompany() {
when(companyMapper.selectById(2L)).thenReturn(company(2, "福州数富", 1));
when(companyMapper.selectCount(any())).thenReturn(1L);
assertThatThrownBy(() -> companyService.update(operator("super_admin", 1L), 2L, request("厦门米椿花", 1, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("已存在");
verify(companyMapper, never()).updateById(any(CompanyEntity.class));
}
@Test
@DisplayName("查重排除自己:只改备注/状态时不能被判成重名")
void duplicateCheckOnUpdateExcludesTheCompanyItself() {
when(companyMapper.selectById(2L)).thenReturn(company(2, "福州数富", 1));
when(companyMapper.selectCount(any())).thenReturn(0L);
companyService.update(operator("super_admin", 1L), 2L, request("福州数富", 1, "只改备注"));
LambdaQueryWrapper<CompanyEntity> query = capturedSelectCount();
assertThat(query.getParamNameValuePairs()).containsValues("福州数富", 2L);
}
@Test
@DisplayName("超管改名 + 停用一起落库,按 id 更新这一条")
void updateWritesNameStatusAndRemark() {
when(companyMapper.selectById(2L)).thenReturn(company(2, "福州数富", 1));
when(companyMapper.selectCount(any())).thenReturn(0L);
companyService.update(operator("super_admin", 1L), 2L, request(" 福州数富科技 ", 0, " 改名并停用 "));
ArgumentCaptor<CompanyEntity> captor = ArgumentCaptor.forClass(CompanyEntity.class);
verify(companyMapper).updateById(captor.capture());
assertThat(captor.getValue().getId()).isEqualTo(2L);
assertThat(captor.getValue().getCompanyName()).isEqualTo("福州数富科技");
assertThat(captor.getValue().getStatus()).isEqualTo(CompanyService.STATUS_DISABLED);
assertThat(captor.getValue().getRemark()).isEqualTo("改名并停用");
}
}
@@ -0,0 +1,128 @@
package com.nanri.aiimage.modules.company.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 登录/顶栏要显示公司名(设计文档 §2.4),所以这条读路径的口径是「显示」,不是「校验」。
*
* <p>它被每次登录调用,因此绝不能挡路:查不到公司、公司停用,都只让名字变空,
* 不抛异常。要是这里改成 {@code requireActive},停用一个公司就会把它的账号全部锁在门外。</p>
*/
class CompanyServiceNameLookupTest {
private CompanyMapper companyMapper;
private CompanyService companyService;
@BeforeEach
@SuppressWarnings("unchecked")
void setUp() {
// namesByIds 用 LambdaQueryWrapper.in(CompanyEntity::getId, ...),取列名依赖 TableInfo 缓存,
// 单测没有 Spring 上下文,手工钉一次(否则 lambda 解析在 CI 上取决于类执行顺序)。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), CompanyEntity.class);
companyMapper = mock(CompanyMapper.class);
companyService = new CompanyService(companyMapper, mock(AdminAuthSupport.class),
mock(PermissionMenuService.class));
}
private CompanyEntity company(Long id, String name, int status) {
CompanyEntity entity = new CompanyEntity();
entity.setId(id);
entity.setCompanyName(name);
entity.setStatus(status);
return entity;
}
@Test
@DisplayName("没有公司归属的账号:直接空串,不去查表")
void nullCompanyAddsNoQuery() {
assertThat(companyService.nameOrEmpty(null)).isEmpty();
// 用 any() 而不是 anyLong():null 入参不会被 anyLong() 记成一次匹配,
// 那样「实现其实查了库、还把 null 传进去」这条反而验不出来。
verify(companyMapper, never()).selectById(any());
}
@Test
@DisplayName("账号挂在已被删掉的公司 id 上:名字读成空串,不许抛")
void unknownCompanyReadsAsEmptyNameNotAnError() {
when(companyMapper.selectById(9L)).thenReturn(null);
assertThatCode(() -> companyService.nameOrEmpty(9L)).doesNotThrowAnyException();
assertThat(companyService.nameOrEmpty(9L)).isEmpty();
}
@Test
@DisplayName("查得到就回公司名")
void returnsTheStoredCompanyName() {
when(companyMapper.selectById(5L))
.thenReturn(company(5L, "厦门米椿花", CompanyService.STATUS_ACTIVE));
assertThat(companyService.nameOrEmpty(5L)).isEqualTo("厦门米椿花");
}
@Test
@DisplayName("停用的公司照样显示名字:这里是显示口径,不是准入口径")
void disabledCompanyStillShowsItsName() {
when(companyMapper.selectById(5L))
.thenReturn(company(5L, "厦门米椿花", CompanyService.STATUS_DISABLED));
assertThat(companyService.nameOrEmpty(5L)).isEqualTo("厦门米椿花");
}
/**
* 列表页批量取名走这个方法(§2.3)。AdminUserListCompanyTest 把 CompanyService mock 掉了,
* 它捕获的是调用方传出的参数,摸不到这里的实现——所以去重/空输入这两条只能在本类用真实对象钉。
*/
@Test
@DisplayName("批量取名:重复 id 折成一次查询,IN 条件里每个公司只出现一遍")
@SuppressWarnings({"unchecked", "rawtypes"})
void batchLookupSendsEachCompanyIdOnce() {
when(companyMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(
List.of(company(5L, "厦门米椿花", CompanyService.STATUS_ACTIVE),
company(7L, "福州数富", CompanyService.STATUS_ACTIVE)));
assertThat(companyService.namesByIds(List.of(5L, 5L, 7L, 5L)))
.containsEntry(5L, "厦门米椿花")
.containsEntry(7L, "福州数富");
ArgumentCaptor<LambdaQueryWrapper<CompanyEntity>> query =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(companyMapper).selectList(query.capture());
// 先碰一次 getSqlSegment(),MP 才把条件参数铺进 paramNameValuePairs
query.getValue().getSqlSegment();
assertThat(query.getValue().getParamNameValuePairs().values())
.containsExactlyInAnyOrder(5L, 7L);
}
@Test
@DisplayName("批量取名:空列表(含 null)不碰公司表,一页没有账号就该一条 SQL 都不发")
void batchLookupOnEmptyInputSkipsTheTable() {
when(companyMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(List.of());
assertThat(companyService.namesByIds(List.of())).isEmpty();
assertThat(companyService.namesByIds(null)).isEmpty();
verify(companyMapper, never()).selectList(any(LambdaQueryWrapper.class));
}
}
@@ -0,0 +1,62 @@
package com.nanri.aiimage.modules.company.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* 多公司一期(设计文档 §2.2):建号指定的公司必须真实存在且处于启用态,
* 否则账号会挂在一个查不到的公司上(列表按公司筛选时它整体失明)。
*/
class CompanyServiceRequireActiveTest {
@Test
void unknownCompanyIsRejected() {
CompanyMapper mapper = mock(CompanyMapper.class);
when(mapper.selectById(9L)).thenReturn(null);
assertThatThrownBy(() -> service(mapper).requireActive(9L))
.isInstanceOf(BusinessException.class);
}
@Test
void disabledCompanyIsRejected() {
CompanyMapper mapper = mock(CompanyMapper.class);
when(mapper.selectById(9L)).thenReturn(company(9L, 0));
assertThatThrownBy(() -> service(mapper).requireActive(9L))
.isInstanceOf(BusinessException.class);
}
/**
* 正例必须存在:否则上面两条红会被"requireActive 无条件抛"的实现骗过去。
*/
@Test
void activeCompanyIsReturned() {
CompanyMapper mapper = mock(CompanyMapper.class);
when(mapper.selectById(7L)).thenReturn(company(7L, 1));
CompanyEntity company = service(mapper).requireActive(7L);
assertThat(company.getId()).isEqualTo(7L);
}
private CompanyService service(CompanyMapper mapper) {
return new CompanyService(mapper, mock(AdminAuthSupport.class), mock(PermissionMenuService.class));
}
private CompanyEntity company(Long id, Integer status) {
CompanyEntity entity = new CompanyEntity();
entity.setId(id);
entity.setStatus(status);
return entity;
}
}