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 f81d89bae1
commit 4dbac40ef3
33 changed files with 2454 additions and 12 deletions
@@ -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;
}
}