test(project): Improve code coverage to meet configured thresholds

Add targeted tests to bring @ui5/project coverage above the configured
thresholds (95% statements, 90% branches, 95% functions, 95% lines).
Also fix AVA timeout for parallel test execution and remove dead code
module utils/sanitizeFileName.js.

New test files:
- build/cache/utils.js, index/TreeNode.js, index/ResourceIndex.js
- build/BuildReader.js, helpers/WatchHandler.js, helpers/ProjectBuilderOutputStyle.js
- ui5framework/maven/CacheMode.js

Extended existing tests:
- HashTree.js, SharedHashTree.js, CacheManager.js
- specifications/Project.js, types/Component.js, types/Library.js
- types/Module.js, types/ThemeLibrary.js, extensions/Task.js

Author: RandomByte

packages/project/ava.config.js

@@ -1,3 +1,6 @@
 import avaCommonConfig from "../../ava.common.config.js";
 
-export default avaCommonConfig;
+export default {
+	...avaCommonConfig,
+	timeout: "5m",
+};

packages/project/lib/utils/sanitizeFileName.js

@@ -0,0 +1 @@
+// test resource

packages/project/test/fixtures/component.a/test/TestFile.js

@@ -0,0 +1,116 @@
+import test from "ava";
+import sinon from "sinon";
+import BuildReader from "../../../lib/build/BuildReader.js";
+
+function createMockProject(name, namespace, type = "library") {
+	return {
+		getName: () => name,
+		getNamespace: () => namespace,
+		getType: () => type,
+	};
+}
+
+test.afterEach.always(() => {
+	sinon.restore();
+});
+
+test("constructor: throws when multiple projects share a namespace", (t) => {
+	const projects = [
+		createMockProject("proj-a", "my/namespace"),
+		createMockProject("proj-b", "my/namespace"),
+	];
+	t.throws(() => new BuildReader("test", projects, {}), {
+		message: /Multiple projects with namespace 'my\/namespace' found/
+	});
+});
+
+test("byGlob: delegates to combined reader", async (t) => {
+	const projects = [createMockProject("proj-a", "my/ns")];
+	const mockReader = {byGlob: sinon.stub().resolves([{path: "/a.js"}])};
+	const buildServerInterface = {
+		getReaderForProjects: sinon.stub().resolves(mockReader),
+	};
+	const reader = new BuildReader("test", projects, buildServerInterface);
+	const result = await reader.byGlob("**/*.js");
+	t.deepEqual(result, [{path: "/a.js"}]);
+	t.is(buildServerInterface.getReaderForProjects.firstCall.args[0][0], "proj-a");
+});
+
+test("byPath: returns resource from primary reader", async (t) => {
+	const projects = [createMockProject("proj-a", "my/ns")];
+	const resource = {getPath: () => "/resources/my/ns/a.js"};
+	const mockReader = {byPath: sinon.stub().resolves(resource)};
+	const buildServerInterface = {
+		getReaderForProject: sinon.stub().resolves(mockReader),
+		getReaderForProjects: sinon.stub().resolves(mockReader),
+	};
+	const reader = new BuildReader("test", projects, buildServerInterface);
+	const result = await reader.byPath("/resources/my/ns/a.js");
+	t.is(result, resource);
+});
+
+test("byPath: falls back to all projects when primary reader returns null", async (t) => {
+	const projects = [createMockProject("proj-a", "my/ns")];
+	const resource = {getPath: () => "/resources/my/ns/a.js"};
+	const primaryReader = {byPath: sinon.stub().resolves(null)};
+	const fallbackReader = {byPath: sinon.stub().resolves(resource)};
+	const buildServerInterface = {
+		getReaderForProject: sinon.stub().resolves(primaryReader),
+		getReaderForProjects: sinon.stub().resolves(fallbackReader),
+	};
+	const reader = new BuildReader("test", projects, buildServerInterface);
+	const result = await reader.byPath("/resources/my/ns/a.js");
+	t.is(result, resource);
+});
+
+test("_getReaderForResource: final fallback when path doesn't match any namespace", async (t) => {
+	const projects = [
+		createMockProject("proj-a", "ns/a"),
+		createMockProject("proj-b", "ns/b"),
+	];
+	const mockReader = {byPath: sinon.stub().resolves(null)};
+	const buildServerInterface = {
+		getReaderForProjects: sinon.stub().resolves(mockReader),
+		getCachedReadersForProjects: sinon.stub().returns(null),
+	};
+	const reader = new BuildReader("test", projects, buildServerInterface);
+	const result = await reader.byPath("/resources/unknown/path.js");
+	t.is(result, null);
+	t.true(buildServerInterface.getReaderForProjects.called);
+});
+
+test("_getReaderForResource: uses cached reader to identify project", async (t) => {
+	const projects = [
+		createMockProject("proj-a", "ns/a"),
+		createMockProject("proj-b", "ns/b"),
+	];
+	const foundResource = {getProject: () => ({getName: () => "proj-a"})};
+	const cachedReader = {byPath: sinon.stub().resolves(foundResource)};
+	const projectReader = {byPath: sinon.stub().resolves(foundResource)};
+	const buildServerInterface = {
+		getReaderForProject: sinon.stub().resolves(projectReader),
+		getReaderForProjects: sinon.stub().resolves(projectReader),
+		getCachedReadersForProjects: sinon.stub().returns(cachedReader),
+	};
+	const reader = new BuildReader("test", projects, buildServerInterface);
+	const result = await reader.byPath("/resources/other/path.js");
+	t.is(result, foundResource);
+});
+
+test("_getReaderForResource: application fallback for non-resource paths", async (t) => {
+	const projects = [
+		createMockProject("my-app", "my/app", "application"),
+		createMockProject("my-lib", "my/lib"),
+	];
+	const foundResource = {getPath: () => "/index.html"};
+	const appReader = {byPath: sinon.stub().resolves(foundResource)};
+	const cachedReader = {byPath: sinon.stub().resolves(null)};
+	const buildServerInterface = {
+		getReaderForProject: sinon.stub().resolves(appReader),
+		getReaderForProjects: sinon.stub().resolves(appReader),
+		getCachedReadersForProjects: sinon.stub().returns(cachedReader),
+	};
+	const reader = new BuildReader("test", projects, buildServerInterface);
+	const result = await reader.byPath("/index.html");
+	t.is(result, foundResource);
+});

packages/project/test/lib/build/BuildReader.js

@@ -136,3 +136,100 @@ test.serial("create() returns singleton per cache directory", async (t) => {
 	const cm2 = await CacheManager.create(testDir);
 	t.is(cm1, cm2, "Same cache directory returns same instance");
 });
+
+test.serial("readContentRaw returns stored buffer", async (t) => {
+	const testDir = getUniqueTestDir();
+	const CacheManager = (await import("../../../../lib/build/cache/CacheManager.js")).default;
+	const cm = new CacheManager(path.join(testDir, "buildCache"));
+
+	const content = Buffer.from("test content for raw read");
+	cm.putContent("sha256-raw", content);
+	const raw = cm.readContentRaw("sha256-raw");
+	t.truthy(raw, "Returns a value");
+	cm.close();
+});
+
+test.serial("putCompressedContent stores pre-compressed data that readContent decompresses", async (t) => {
+	const testDir = getUniqueTestDir();
+	const {gzipSync} = await import("node:zlib");
+	const CacheManager = (await import("../../../../lib/build/cache/CacheManager.js")).default;
+	const cm = new CacheManager(path.join(testDir, "buildCache"));
+
+	const content = Buffer.from("compressed content");
+	const compressed = gzipSync(content);
+	cm.putCompressedContent("sha256-comp", compressed);
+	const decompressed = cm.readContent("sha256-comp");
+	t.deepEqual(decompressed, content, "readContent returns decompressed content");
+	cm.close();
+});
+
+test.serial("writeStageResource writes resource by integrity", async (t) => {
+	const testDir = getUniqueTestDir();
+	const CacheManager = (await import("../../../../lib/build/cache/CacheManager.js")).default;
+	const cm = new CacheManager(path.join(testDir, "buildCache"));
+
+	const resource = {
+		getIntegrity: async () => "sha256-stage",
+		getBuffer: async () => Buffer.from("stage resource content")
+	};
+	await cm.writeStageResource(resource);
+	t.true(cm.hasContent("sha256-stage"));
+	t.deepEqual(cm.readContent("sha256-stage"), Buffer.from("stage resource content"));
+	cm.close();
+});
+
+test.serial("Batch operations: content batch begin/end", async (t) => {
+	const testDir = getUniqueTestDir();
+	const CacheManager = (await import("../../../../lib/build/cache/CacheManager.js")).default;
+	const cm = new CacheManager(path.join(testDir, "buildCache"));
+
+	cm.beginContentBatch();
+	cm.putContent("sha256-batch1", Buffer.from("batch1"));
+	cm.putContent("sha256-batch2", Buffer.from("batch2"));
+	cm.endContentBatch();
+
+	t.true(cm.hasContent("sha256-batch1"));
+	t.true(cm.hasContent("sha256-batch2"));
+	cm.close();
+});
+
+test.serial("Batch operations: content batch rollback", async (t) => {
+	const testDir = getUniqueTestDir();
+	const CacheManager = (await import("../../../../lib/build/cache/CacheManager.js")).default;
+	const cm = new CacheManager(path.join(testDir, "buildCache"));
+
+	cm.beginContentBatch();
+	cm.putContent("sha256-rollback", Buffer.from("rollback"));
+	cm.rollbackContentBatch();
+
+	t.false(cm.hasContent("sha256-rollback"), "Content should not exist after rollback");
+	cm.close();
+});
+
+test.serial("Batch operations: metadata batch begin/end", async (t) => {
+	const testDir = getUniqueTestDir();
+	const CacheManager = (await import("../../../../lib/build/cache/CacheManager.js")).default;
+	const cm = new CacheManager(path.join(testDir, "buildCache"));
+
+	cm.beginMetadataBatch();
+	await cm.writeIndexCache("proj-batch", "sig", "source", {data: true});
+	cm.endMetadataBatch();
+
+	const result = await cm.readIndexCache("proj-batch", "sig", "source");
+	t.deepEqual(result, {data: true});
+	cm.close();
+});
+
+test.serial("Batch operations: metadata batch rollback", async (t) => {
+	const testDir = getUniqueTestDir();
+	const CacheManager = (await import("../../../../lib/build/cache/CacheManager.js")).default;
+	const cm = new CacheManager(path.join(testDir, "buildCache"));
+
+	cm.beginMetadataBatch();
+	await cm.writeIndexCache("proj-rollback", "sig", "source", {data: true});
+	cm.rollbackMetadataBatch();
+
+	const result = await cm.readIndexCache("proj-rollback", "sig", "source");
+	t.is(result, null, "Metadata should not exist after rollback");
+	cm.close();
+});

packages/project/test/lib/build/cache/CacheManager.js

@@ -756,3 +756,65 @@ test("Intermediate directory hashes are correct after deep leaf modification", a
 	t.is(tree.getRootHash(), referenceTree.getRootHash(),
 		"Root hash must match reference");
 });
+
+test("hasDirectoryChanged: returns true when directory hash differs", (t) => {
+	const resources = [
+		{path: "dir/file1.js", integrity: "hash1"},
+		{path: "dir/file2.js", integrity: "hash2"}
+	];
+	const tree = new HashTree(resources);
+	const previousHash = "some-old-hash";
+	t.true(tree.hasDirectoryChanged("dir", previousHash));
+});
+
+test("hasDirectoryChanged: returns false when directory hash matches", (t) => {
+	const resources = [
+		{path: "dir/file1.js", integrity: "hash1"}
+	];
+	const tree = new HashTree(resources);
+	const currentHash = tree.getDirectoryHash("dir");
+	t.false(tree.hasDirectoryChanged("dir", currentHash));
+});
+
+test("getStats: returns resource/directory counts and depth", (t) => {
+	const resources = [
+		{path: "a.js", integrity: "hash-a"},
+		{path: "dir/b.js", integrity: "hash-b"},
+		{path: "dir/sub/c.js", integrity: "hash-c"}
+	];
+	const tree = new HashTree(resources);
+	const stats = tree.getStats();
+	t.is(stats.resources, 3);
+	t.is(stats.directories, 3); // root, dir, dir/sub
+	t.is(stats.maxDepth, 3); // c.js is at depth 3 (root=0, dir=1, sub=2, c.js=3)
+	t.is(stats.rootHash, tree.getRootHash());
+});
+
+test("validate: returns true for valid tree", (t) => {
+	const resources = [
+		{path: "file.js", integrity: "hash1"},
+		{path: "dir/file2.js", integrity: "hash2"}
+	];
+	const tree = new HashTree(resources);
+	t.true(tree.validate());
+});
+
+test("clone: creates independent copy", async (t) => {
+	const resources = [
+		{path: "file1.js", integrity: "hash1", lastModified: 1000, size: 100},
+		{path: "dir/file2.js", integrity: "hash2", lastModified: 2000, size: 200}
+	];
+	const tree = new HashTree(resources);
+	const cloned = tree.clone();
+
+	t.is(cloned.getRootHash(), tree.getRootHash(), "Clone has same root hash");
+
+	// Mutating clone should not affect original
+	const indexTimestamp = cloned.getIndexTimestamp();
+	await cloned.upsertResources([createMockResource("file1.js", "new-hash", indexTimestamp + 1, 101, 1)]);
+	t.not(cloned.getRootHash(), tree.getRootHash(), "Original unchanged after clone mutation");
+});
+
+test("fromCache: throws on unsupported version", (t) => {
+	t.throws(() => HashTree.fromCache({version: 99, root: {}}), {message: /Unsupported version/});
+});