Files
crawler-plugin/backend-java/src/test/java/com/nanri/aiimage/testutil/SourceScanTest.java
T
huangzd1997 768f8e0573 test(phase-3): 3A 拆件后同步 SourceScan 的面数见证——28→30、5→7,并让 witness 真指到新件
全量 mvn -o test 4518 例里唯一两记红都在这一支,红因是本会话的拆件:modules/appearancepatent
的服务面从 28 支涨到 30 支(support 从 5 涨到 7——新增 TaskOwnership 与 StaleTaskScanner)。

改法按该格自己的判据来。它原文写的就是「聚合入口存在的理由=拆分后的新文件要自动被看到」,
所以这不是一枚需要放宽的上限,而是一枚需要跟着真面走的**分母见证**:
- 方法名里的 28 一并改成 30(名字与断言不符就是下一处读数坑);
- 逐层拆解的注释同步(5 service/support → 7,并注明 7=既有 5+3A 新落 2);
- 另加两条 anyMatch,点名新落的两枚文件必须在面里。只把数字改大而不指到具体新件,
  下一回拆件就又会只剩一个「数不对」的红,而这条护栏真正要证的是「扫得到」。

其余判据一条未动(dto 7/vo 9 未变,model 那两层嵌套没受影响)。
SourceScanTest 40 例全绿;后端全量重跑读数随后登记。
2026-10-19 12:00:39 +08:00

626 lines
32 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package com.nanri.aiimage.testutil;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
/**
* {@link SourceScan} 自己的护栏(2026-10-16,plan 01 N4 起)。
*
* <p><b>N4 点名普查台账</b>(由 {@code census_sourceText调用点总数不少于10} 那格机器复算,不是手抄):</p>
* <pre>
* 被点名裸名(10 个唯一) 字面量调用点 出处
* ---------------------------------------------------------------------------
* PublishController.java 3 PublishOwnershipGuardrailTest:42 :82 :96
* AdminApiGuardFilter.java 2 AdminGuardSwitchConfigTest:107 :254
* AdminDeviceLogController.java 2 DeviceLogServiceTest:412 :428
* LockSkipWitness.java 2 LockSkipWitnessTest:178 + LockSkipSilentExitGuardrailTest:153
* AppearancePatentTaskService.java 1 PublishOwnershipGuardrailTest:111
* PublishTaskService.java 1 PublishOwnershipGuardrailTest:109
* SimilarAsinTaskService.java 1 PublishOwnershipGuardrailTest:112
* ClientVersionGuardFilter.java 1 ClientVersionFloorConfigTest:249
* PermissionMenuService.java 1 MenuWriteOutletOperatorTest:30
* ShopManageController.java 1 ShopManageServiceTest:185
* ---------------------------------------------------------------------------
* 合计 15 落在 <b>8</b> 支调用方文件里
* </pre>
*
* <p><b>一处与 plan 原文不符的读数,按"先怀疑尺子"的流程处理并留在脸上</b>:plan/AGENTS §1 记的是「9 支文件」,
* 那条数是 {@code grep -rl 'sourceText('} 数出来的,而第 9 支是 {@code SourceScan.java:22} 里
* {@code public static String sourceText(String fileName)} 这行<b>被调方自己的声明</b>——它不是调用点。
* 所以真实形状是 <b>15 个调用点/8 支调用方/9 支引用方文件</b>。下面第 3 格把这三个数同时钉住,
* 免得下一个人拿 {@code grep} 再数一遍又把声明算进去。</p>
*/
class SourceScanTest {
/** 台账里登记过的 10 个被点名裸名,逐字对撞用。 */
private static final Set<String> REGISTERED_BARE_NAMES = Set.of(
"PublishController.java",
"PublishTaskService.java",
"AppearancePatentTaskService.java",
"SimilarAsinTaskService.java",
"AdminApiGuardFilter.java",
"AdminDeviceLogController.java",
"ClientVersionGuardFilter.java",
"LockSkipWitness.java",
"PermissionMenuService.java",
"ShopManageController.java");
@TempDir
Path tmp;
@Test
void census_sourceText调用点总数不少于10() {
List<SourceScan.CallSite> sites = SourceScan.censusSourceTextCallSites();
assertThat(sites)
.as("普查扫到的字面量调用点总数——下限判据:扫到 0 会被误读成「已经没人点名单文件了」,"
+ "而真相往往是语料根没找对")
.hasSizeGreaterThanOrEqualTo(10);
}
@Test
void census_唯一裸名恰为10且与已登记集合相等() {
Set<String> found = SourceScan.censusSourceTextCallSites().stream()
.map(SourceScan.CallSite::bareName)
.collect(Collectors.toSet());
assertThat(found)
.as("唯一裸名集合必须与类头台账逐字相等——多一个说明有人新引了单文件口径,少一个说明尺子漏扫")
.isEqualTo(REGISTERED_BARE_NAMES)
.hasSize(10);
}
@Test
void census_涉及文件恰为9() {
List<SourceScan.CallSite> sites = SourceScan.censusSourceTextCallSites();
Set<String> callerFiles = sites.stream()
.map(SourceScan.CallSite::relativeFile)
.collect(Collectors.toSet());
String declarationFile = "src/test/java/com/nanri/aiimage/testutil/SourceScan.java";
assertThat(callerFiles)
.as("真实字面量调用点落在 8 支调用方文件里")
.hasSize(8);
assertThat(callerFiles)
.as("plan 原文记的「9 支」= grep -rl 'sourceText(' 的条数,第 9 支是被调方自己的声明行"
+ "(SourceScan.java:22 的 `public static String sourceText(String fileName)`),"
+ "它不是调用点。这里把「声明件必须落在调用方集合之外」钉成机器判,"
+ "免得下一个人再拿 grep 数一遍把声明算进分母")
.doesNotContain(declarationFile);
assertThat(Path.of(declarationFile)).exists();
}
@Test
void census_空语料目录返回空而非抛() throws IOException {
Path empty = Files.createDirectories(tmp.resolve("empty_corpus"));
assertThat(SourceScan.censusSourceTextCallSites(empty))
.as("目录存在且确实是空的 ⇒ 返回空表。这与「目录不存在必须抛」是两回事,"
+ "前者是语料真的没了,后者是尺子架错了地方")
.isEmpty();
}
@Test
void census_中文路径文件被计入不丢失() throws IOException {
Path corpus = Files.createDirectories(tmp.resolve("语料根"));
Path chineseDir = Files.createDirectories(corpus.resolve("中文语料"));
Files.writeString(chineseDir.resolve("点名中文件.java"),
"class A { void x() { SourceScan.sourceText(\"PublishController.java\"); } }",
StandardCharsets.UTF_8);
List<SourceScan.CallSite> sites = SourceScan.censusSourceTextCallSites(corpus);
assertThat(sites)
.as("本仓有几百支中文名的测试件;遍历若按非 UTF-8 出口处理就会静默漏掉它们")
.singleElement()
.satisfies(site -> {
assertThat(site.bareName()).isEqualTo("PublishController.java");
assertThat(site.relativeFile()).contains("中文语料");
});
}
@Test
void census_同名多次调用逐条计数不合并() {
List<SourceScan.CallSite> publishController = SourceScan.censusSourceTextCallSites().stream()
.filter(site -> site.bareName().equals("PublishController.java"))
.toList();
assertThat(publishController)
.as("同一个裸名被点 3 次就必须是 3 条,按名去重会把「三格钉同一方法」这族形状抹平")
.hasSize(3)
.extracting(SourceScan.CallSite::line)
.containsExactlyInAnyOrder(42, 82, 96);
}
@Test
void census_非法正则模式不影响解析() throws IOException {
Path corpus = Files.createDirectories(tmp.resolve("混淆语料"));
Files.writeString(corpus.resolve("Mixed.java"), String.join("\n",
"class Mixed {",
" // 有人在注释里写 SourceScan.sourceText(\"CommentFake.java\") —— 这不算点名",
" static final String DOC = \"别学这个 sourceText(\\\"LiteralFake.java\\\") 的写法\";",
" void real() { SourceScan.sourceText(\"RealOne.java\"); }",
"}",
""),
StandardCharsets.UTF_8);
List<SourceScan.CallSite> sites = SourceScan.censusSourceTextCallSites(corpus);
assertThat(sites)
.as("真点名 1 条:注释里的那条要被判掉(护栏数的是代码不是文字),"
+ "字符串字面量里那条带转义引号,正则不该配上")
.singleElement()
.satisfies(site -> assertThat(site.bareName()).isEqualTo("RealOne.java"));
}
@Test
void census_扫不到源码根时抛并回显cwd() {
Path wrong = tmp.resolve("少爬了一层");
assertThatThrownBy(() -> SourceScan.censusSourceTextCallSites(wrong))
.as("根目录不存在时必须炸,不许返回空表——「扫不到」被读成「没人在用」是本族护栏的标准死法")
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("cwd=")
.hasMessageContaining(wrong.toAbsolutePath().toString());
}
// ---------------------------------------------------------------- N5 同名面普查
@Test
void duplicateNames_实测三组且不多不少() {
assertThat(SourceScan.duplicateMainSourceNames().keySet())
.as("src/main/java 下同名 >1 的裸文件名——实测就这三组,多一组说明有新落点,少一组说明有人搬走了")
.containsExactlyInAnyOrder(
"BoundedImageCache.java",
"GroupDeletionGuard.java",
"SkipPriceAsinPageVo.java");
}
@Test
void duplicateNames_与点名单交集为空() {
Set<String> duplicates = SourceScan.duplicateMainSourceNames().keySet();
assertThat(duplicates)
.as("这是 N20 把 sourceText 收紧成「歧义即抛」的前提证明:今天被点名的 10 个裸名"
+ "全部单命中,所以当场不会打红。若未来第 11 个点名撞上这三组之一,"
+ "N20 会当场红——那是正确行为,不是回归")
.doesNotContainAnyElementsOf(REGISTERED_BARE_NAMES);
}
@Test
void duplicateNames_全树java数不少于900() {
assertThat(SourceScan.mainSourceFiles())
.as("分母下限:扫到 0 支必须被读成尺子坏了,而不是「主源码空了」")
.hasSizeGreaterThanOrEqualTo(900);
}
@Test
void duplicateNames_唯一名数小于总文件数() {
List<Path> all = SourceScan.mainSourceFiles();
long uniqueNames = all.stream()
.map(p -> p.getFileName().toString())
.distinct()
.count();
assertThat(uniqueNames)
.as("973 支文件 / 970 个唯一名 ⇒ 确有 3 组同名。相等就说明同名面被搬空了,N5 的台账要同步改")
.isLessThan((long) all.size());
}
@Test
void duplicateNames_空目录返回空集合() throws IOException {
Path empty = Files.createDirectories(tmp.resolve("空树"));
assertThat(SourceScan.duplicateSourceNames(empty))
.as("目录存在且没有 .java ⇒ 空 Map(与 N4 的「语料真空」同一条口径)")
.isEmpty();
}
@Test
void duplicateNames_同名恰好三支时计数为3() throws IOException {
for (String dir : new String[] {"a", "b/c", "d/e/f"}) {
Path sub = Files.createDirectories(tmp.resolve("三支").resolve(dir));
Files.writeString(sub.resolve("Trio.java"), "class Trio {}", StandardCharsets.UTF_8);
}
assertThat(SourceScan.duplicateSourceNames(tmp.resolve("三支")))
.as("三支同名必须聚成一组、值为 3 条路径;分组写成「每对相邻比较」就会数出 3 组")
.containsEntry("Trio.java", List.of(
"a/Trio.java", "b/c/Trio.java", "d/e/f/Trio.java"));
}
@Test
void duplicateNames_忽略非java文件同名() throws IOException {
Path tree = Files.createDirectories(tmp.resolve("混放树"));
Files.createDirectories(tree.resolve("docs"));
Files.writeString(tree.resolve("Foo.java"), "class Foo {}", StandardCharsets.UTF_8);
Files.writeString(tree.resolve("docs").resolve("Foo.md"), "# Foo", StandardCharsets.UTF_8);
assertThat(SourceScan.duplicateSourceNames(tree))
.as("`Foo.md` 与 `Foo.java` 不同名——只按裸名分组会把文档也算成同名,聚合面就多吃一支")
.isEmpty();
}
@Test
void duplicateNames_路径不可读时抛不静默跳过() throws IOException {
Path notADirectory = Files.writeString(tmp.resolve("我是文件不是目录"), "x", StandardCharsets.UTF_8);
assertThatThrownBy(() -> SourceScan.duplicateSourceNames(notADirectory))
.as("传进来的是文件而非目录 ⇒ 必须抛。静默返回空 Map 会被读成「主源码没有同名件」")
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("cwd=");
}
// ---------------------------------------------------------------- N6 moduleSources
@Test
void moduleSources_appearancepatent返回30支含拆分后的support件() {
List<Path> files = SourceScan.moduleSources("modules/appearancepatent");
assertThat(files)
.as("真实集成:对真仓目录求值。30 支=1 controller+1 client+1 service 主件+3 spi/cache+"
+ "7 service/support+16 model(dto7/vo9),与 find 实测同号")
.hasSize(30);
assertThat(files.stream().map(p -> p.toString().replace('\\', '/')).toList())
.as("support 目录里的既有件必须在面里——聚合入口存在的理由就是拆分后的新文件要自动被看到")
.anyMatch(rel -> rel.endsWith("service/support/AppearancePatentRowNormalizer.java"));
}
@Test
void moduleSources_返回列表不可变() {
List<Path> files = SourceScan.moduleSources("modules/appearancepatent");
assertThatThrownBy(() -> files.add(Path.of("塞一支进去.java")))
.as("调用方改坏面 ⇒ 同一轮里后一格读到的就不是真面了")
.isInstanceOf(UnsupportedOperationException.class);
}
@Test
void moduleSources_相对路径与绝对路径两种写法都接受() {
List<Path> plain = SourceScan.moduleSources("modules/appearancepatent");
assertThat(SourceScan.moduleSources("/modules/appearancepatent"))
.as("前导斜杠写法与裸相对写法必须同面,否则同一个模块会有两种口径")
.isEqualTo(plain);
assertThat(SourceScan.moduleSources("modules/appearancepatent/"))
.as("尾斜杠同理")
.isEqualTo(plain);
assertThat(SourceScan.moduleSources("modules\\appearancepatent"))
.as("Windows 反斜杠写法")
.isEqualTo(plain);
}
@Test
void moduleSources_空目录场景留给N11本task先返回空() throws IOException {
Path javaRoot = Files.createDirectories(tmp.resolve("N6空场景树/src/main/java"));
Files.createDirectories(javaRoot.resolve("modules/zzz_empty"));
assertThat(SourceScan.moduleSources(javaRoot, "modules/zzz_empty"))
.as("N6 只定「正常返回」:目录存在且为空 ⇒ 先返回空表不抛。"
+ "N11 会把这条改成抛(零文件绝不许读成零违规),届时更新本例")
.isEmpty();
}
@Test
void moduleSources_深层相对路径越界到src外时拒绝() {
assertThatThrownBy(() -> SourceScan.moduleSources("modules/../../../Windows"))
.as("`..` 逃逸出 src/main/java ⇒ 必须挡。挡不住就等于聚合面能把整台机器读进来")
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("越界");
}
@Test
void moduleSources_路径含中文时正确解析() throws IOException {
Path javaRoot = Files.createDirectories(tmp.resolve("N6中文树/src/main/java"));
Path module = Files.createDirectories(javaRoot.resolve("modules/模块中文"));
Files.writeString(module.resolve("中文件.java"), "class A {}", StandardCharsets.UTF_8);
List<Path> chinese = SourceScan.moduleSources(javaRoot, "modules/模块中文");
assertThat(chinese)
.as("主源码树今天没有中文名件,但语料根与相对目录都得过 UTF-8 这条道:这里用合成树把它钉住")
.hasSize(1);
assertThat(chinese.get(0).getFileName().toString()).isEqualTo("中文件.java");
}
@Test
void moduleSources_返回类型是Path不是字符串() {
List<Path> files = SourceScan.moduleSources("modules/appearancepatent");
assertThat(files).allSatisfy(p -> assertThat(p).isInstanceOf(Path.class));
assertThat(files).allSatisfy(p -> assertThat(p.isAbsolute()).isTrue());
assertThat(files).allSatisfy(p -> assertThat(Files.isRegularFile(p)).isTrue());
}
@Test
void moduleSources_找不到源码根时抛并回显cwd() {
Path wrong = tmp.resolve("少爬了一层/src/main/java");
assertThatThrownBy(() -> SourceScan.moduleSources(wrong, "modules/appearancepatent"))
.as("根目录不存在必须抛并回显 cwd——静默返回空表会让整条聚合护栏恒绿")
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("cwd=")
.hasMessageContaining(Path.of("").toAbsolutePath().toString());
}
// ---------------------------------------------------------------- N7 递归语义
@Test
void recursive_包含service下的直接件() {
assertThat(SourceScan.moduleSources("modules/appearancepatent"))
.as("模块根下第一层的 service/ 直接件必须在面里")
.anyMatch(p -> p.toString().replace('\\', '/').endsWith(
"service/AppearancePatentTaskService.java"));
}
@Test
void recursive_包含service_support下的既有7件() {
List<String> support = SourceScan.moduleSources("modules/appearancepatent").stream()
.map(p -> p.toString().replace('\\', '/'))
.filter(rel -> rel.contains("/service/support/"))
.toList();
assertThat(support)
.as("真实集成:对真仓 modules/appearancepatent/service/support 求值,实测 7 支(3A 拆薄把归属谓词与陈旧扫描抽成两枚 support 件,5→7)。"
+ "这一格就是聚合入口存在的理由——拆分出去的新文件必须自动进面")
.hasSize(7);
}
@Test
void recursive_包含model下两层dto与vo() {
List<String> rel = SourceScan.moduleSources("modules/appearancepatent").stream()
.map(p -> p.toString().replace('\\', '/'))
.toList();
assertThat(rel.stream().filter(p -> p.contains("/model/dto/")).count())
.as("model/dto 一层嵌套")
.isEqualTo(7);
assertThat(rel.stream().filter(p -> p.contains("/model/vo/")).count())
.as("model/vo 一层嵌套")
.isEqualTo(9);
}
@Test
void recursive_深度为1的目录不出现在面里() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N7深度树/src/main/java/modules/deep"));
Path deep = Files.createDirectories(module.resolve("a/b/c"));
Files.writeString(deep.resolve("D.java"), "class D {}", StandardCharsets.UTF_8);
Files.writeString(module.resolve("Root.java"), "class Root {}", StandardCharsets.UTF_8);
List<Path> files = SourceScan.moduleSources(tmp.resolve("N7深度树/src/main/java"), "modules/deep");
assertThat(files)
.as("三层嵌套里的 a/b/c/D.java 必须被计入:只爬一层的实现会静默漏掉它,"
+ "而 support/ 恰恰就是这一层以下的位置")
.extracting(p -> p.getFileName().toString())
.containsExactlyInAnyOrder("D.java", "Root.java");
assertThat(files)
.as("面里只许有文件——目录本身不是元素,否则聚合文本会多出无内容条目")
.allMatch(Files::isRegularFile);
}
@Test
void recursive_隐藏目录件被排除() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N7隐藏树/src/main/java/modules/vis"));
Path hidden = Files.createDirectories(module.resolve(".git"));
Files.writeString(hidden.resolve("Ghost.java"), "class Ghost {}", StandardCharsets.UTF_8);
Files.writeString(module.resolve("Real.java"), "class Real {}", StandardCharsets.UTF_8);
assertThat(SourceScan.moduleSources(tmp.resolve("N7隐藏树/src/main/java"), "modules/vis"))
.as(".git / .idea 这类目录里的 .java(IDE 与工具生成的副本)不许进面——"
+ "否则同一份代码会被算两遍,精确计数格(publish 恰 1)当场失真")
.extracting(p -> p.getFileName().toString())
.containsExactly("Real.java");
}
@Test
void recursive_符号链接目录不被重复计入() throws IOException, InterruptedException {
Path javaRoot = Files.createDirectories(tmp.resolve("N7链树/src/main/java"));
Path real = Files.createDirectories(javaRoot.resolve("modules/linkreal"));
Files.writeString(real.resolve("One.java"), "class One {}", StandardCharsets.UTF_8);
// Windows 上建符号链接要特权,junction 不用:mklink /J 是本机的可复现路径。
// ⚠ 这里刻意不用 Assumptions 跳过——跳过会新增一格 Skipped,直接违反 N99「一个新 skip 都不许有」,
// 那是拿跳过换绿。建不出来就判红并点名环境缺口(plan N3 第 9 例同一条口径)。
Process mk = new ProcessBuilder("cmd.exe", "/c", "mklink", "/J",
javaRoot.resolve("modules").resolve("linkalias").toString(), real.toString())
.redirectErrorStream(true).start();
String out;
try (var in = mk.getInputStream()) {
out = new String(in.readAllBytes(), StandardCharsets.UTF_8);
}
int mklink = mk.waitFor();
assertThat(mklink)
.as("junction 建不出来 ⇒ 本机环境不支持,这格判红而不是跳过(跳过会新增 Skipped,"
+ "违反 N99「一个新 skip 都不许有」)。cmd 输出:%s", out)
.isZero();
List<Path> files = SourceScan.moduleSources(javaRoot, "modules");
assertThat(files)
.as("目录联接指回同一棵树:本机实测 Files.walk 会照钻 junction(改之前读出 [One.java, One.java]),"
+ "所以「默认不 FOLLOW_LINKS 就安全」这条假设已被证伪。实现按 toRealPath() 折叠同一份文件"
+ "(公开 NIO 读不到重解析点标志);重复计入会让精确计数格(publish 恰 1)假绿")
.extracting(p -> p.getFileName().toString())
.containsExactly("One.java");
}
@Test
void recursive_目录内全是非java时命中为空() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N7非java树/src/main/java/modules/docs"));
Files.writeString(module.resolve("README.md"), "# 迁移说明", StandardCharsets.UTF_8);
Files.createDirectories(module.resolve("sub"));
Files.writeString(module.resolve("sub").resolve("notes.txt"), "x", StandardCharsets.UTF_8);
assertThat(SourceScan.moduleSources(tmp.resolve("N7非java树/src/main/java"), "modules/docs"))
.as("整棵树没有 .java ⇒ 空表(N11 会把这条改成抛;本格先钉「非 java 不进面」)")
.isEmpty();
}
@Test
void recursive_遍历失败抛IllegalStateException不吞() throws IOException {
Path vanished = tmp.resolve("N7消失树"); // 刻意不创建:walk 必须在第一步就抛 IOException
// 正对照:先证明这里真的会抛 IOException —— 否则「没吞」这条断言是空的
try (var raw = java.nio.file.Files.walk(vanished)) {
raw.toList();
org.junit.jupiter.api.Assertions.fail("JDK 的 Files.walk 在这条路径上没抛,正对照失效");
} catch (java.io.IOException expected) {
assertThat(expected).isInstanceOf(java.nio.file.NoSuchFileException.class);
}
assertThatThrownBy(() -> SourceScan.collectJavaFiles(vanished))
.as("遍历抛 IOException 时必须包成 IllegalStateException 并点名路径,不许吞成空表——"
+ "「扫不到」被读成「没违规」是本族护栏的标准死法(10-15 §12 第一条)")
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("遍历")
.hasMessageContaining(vanished.getFileName().toString());
}
// ---------------------------------------------------------------- N8 只吃 .java
@Test
void exclude_java只计java扩展() {
assertThat(SourceScan.moduleSources("modules/appearancepatent"))
.as("面内每一支都必须以小写 {@code .java} 结尾——大小写策略见 exclude_大写JAVA后缀被计入")
.allMatch(p -> p.getFileName().toString().endsWith(".java"));
}
@Test
void exclude_同目录md文件不进面() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N8混放/src/main/java/modules/mixed"));
Files.writeString(module.resolve("Keep.java"), "class Keep {}", StandardCharsets.UTF_8);
Files.writeString(module.resolve("MIGRATION.md"), "# 拆分说明", StandardCharsets.UTF_8);
Files.writeString(module.resolve("mapper.xml"), "<x/>", StandardCharsets.UTF_8);
Files.writeString(module.resolve("notes.txt"), "x", StandardCharsets.UTF_8);
assertThat(SourceScan.moduleSources(tmp.resolve("N8混放/src/main/java"), "modules/mixed"))
.as("真集成同款场景:SourceScan.java:35-39 记过同类事故——注释类文本会把「被禁写法」喂成假绿。"
+ "正反双向一起断言:留 1 支 .java,同时排除 3 支非 java")
.extracting(p -> p.getFileName().toString())
.containsExactly("Keep.java");
}
@Test
void exclude_大写JAVA后缀被计入() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N8大小写/src/main/java/modules/case"));
Files.writeString(module.resolve("Lower.java"), "class Lower {}", StandardCharsets.UTF_8);
Files.writeString(module.resolve("UPPER.JAVA"), "class UPPER {}", StandardCharsets.UTF_8);
// 本 task 定口径:**大写 .JAVA 不计**(与仓内现状一致)。正反两条同时钉:
// 谁把它改成大小写不敏感匹配,下面那条「不含 UPPER.JAVA」立刻红——这格因此不是恒绿格。
List<String> names = SourceScan.moduleSources(tmp.resolve("N8大小写/src/main/java"), "modules/case")
.stream().map(p -> p.getFileName().toString()).toList();
assertThat(names).contains("Lower.java");
assertThat(names)
.as("口径选择:只认小写 .java。仓内 973 支主源码件实测全是小写后缀,"
+ "把 .JAVA 也收进来等于给「同一份代码换个大小写再放一遍」开绿灯")
.doesNotContain("UPPER.JAVA");
}
@Test
void exclude_以java结尾的目录名不误判() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N8怪目录/src/main/java/modules/weird"));
Path fakeDir = Files.createDirectories(module.resolve("foo.java"));
Files.writeString(fakeDir.resolve("Bar.java"), "class Bar {}", StandardCharsets.UTF_8);
List<Path> files = SourceScan.moduleSources(tmp.resolve("N8怪目录/src/main/java"), "modules/weird");
assertThat(Files.isDirectory(fakeDir))
.as("正对照:这个目录确实叫 foo.java,否则下面那条断言是空的")
.isTrue();
assertThat(files)
.as("目录不是源文件:后缀判定必须先过 isRegularFile(walkFileTree 的 visitFile 天然只给文件,"
+ "但这条换实现就容易踩,所以钉住)")
.extracting(p -> p.getFileName().toString())
.containsExactly("Bar.java");
}
@Test
// plan 原文这格叫「exclude_隐藏文件.java不计入」——含点号做 Java 方法名不合法,改名并在此留痕
void exclude_隐藏文件不计入() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N8隐藏件/src/main/java/modules/dot"));
Files.writeString(module.resolve("Real.java"), "class Real {}", StandardCharsets.UTF_8);
Files.writeString(module.resolve(".Shadow.java"), "class Shadow {}", StandardCharsets.UTF_8);
assertThat(SourceScan.moduleSources(tmp.resolve("N8隐藏件/src/main/java"), "modules/dot"))
.as("以点开头的 .java 是编辑器备份(.Foo.java、Foo.java.orig 一族),进面就会把计数喂大。"
+ "正反双向:真件在、影子件不在")
.extracting(p -> p.getFileName().toString())
.containsExactly("Real.java");
}
@Test
void exclude_空文件被计入但读为空串() throws IOException {
Path module = Files.createDirectories(tmp.resolve("N8空件/src/main/java/modules/zero"));
Path empty = Files.createFile(module.resolve("Empty.java"));
Files.writeString(module.resolve("Kept.java"), "class Kept {}", StandardCharsets.UTF_8);
List<Path> files = SourceScan.moduleSources(tmp.resolve("N8空件/src/main/java"), "modules/zero");
assertThat(Files.size(empty))
.as("正对照:这支确实是 0 字节")
.isZero();
assertThat(files)
.as("有文件但内容为空 ≠ 零文件——这条与 N11「目录里 0 支 .java 才抛」必须分得开,"
+ "否则 N11 会把「全是空件」的模块误判成「没有文件」")
.extracting(p -> p.getFileName().toString())
.containsExactlyInAnyOrder("Empty.java", "Kept.java");
}
@Test
void exclude_不可读文件抛不静默跳过() throws IOException, InterruptedException {
Path root = tmp.resolve("N8不可读/src/main/java");
Path module = Files.createDirectories(root.resolve("modules/locked"));
Path noList = Files.createDirectories(module.resolve("nolist"));
Files.writeString(noList.resolve("Hidden.java"), "class Hidden {}", StandardCharsets.UTF_8);
Process icacls = new ProcessBuilder("icacls", noList.toString(), "/deny", "*S-1-1-0:(OI)(CI)RX")
.redirectErrorStream(true).start();
String out;
try (var in = icacls.getInputStream()) {
out = new String(in.readAllBytes(), StandardCharsets.UTF_8);
}
int code = icacls.waitFor();
try {
assertThat(code)
.as("icacls 造不出「不可列举目录」⇒ 环境缺口,判红而不是跳过(跳过会新增 Skipped,违反 N99)。"
+ "输出:%s", out)
.isZero();
assertThat(Files.isReadable(noList))
.as("反证前提:拒绝授权必须真的生效,否则后面那条断言是恒绿的")
.isFalse();
assertThatThrownBy(() -> SourceScan.moduleSources(root, "modules/locked"))
.as("列举失败的目录必须把异常冒出来(visitFileFailed ⇒ IllegalStateException),"
+ "静默跳过 = 那个子树里的被禁写法永远不会被读到")
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("遍历");
} finally {
// 撤销拒绝授权,否则 JUnit 清 @TempDir 会因无删除权限卡住,把一次性件留在机器上
new ProcessBuilder("icacls", noList.toString(), "/remove:d", "*S-1-1-0")
.redirectErrorStream(true).start().waitFor();
}
}
@Test
void exclude_面内全部元素isRegularFile为真() {
assertThat(SourceScan.moduleSources("modules/shopdatacrawl"))
.as("真实集成:51 支的模块里逐支都必须是regular file,形状契约")
.isNotEmpty()
.allMatch(Files::isRegularFile);
}
}