768f8e0573
全量 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 例全绿;后端全量重跑读数随后登记。
626 lines
32 KiB
Java
626 lines
32 KiB
Java
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);
|
||
}
|
||
}
|