test: add ftp, sftp and file operation tests (#2778)

src/test/fs.tests.js

@@ -201,5 +201,92 @@ export async function runFsTests(writeOutput) {
 		}
 	});
 
+	runner.test("copyTo, moveTo, renameTo", async (test) => {
+		const fs = fsOperation(testDir);
+		const sourceName = `__fs_source_${Date.now()}__.txt`;
+		const destDirName = `__fs_destdir_${Date.now()}__`;
+		const moveDirName = `__fs_movedir_${Date.now()}__`;
+
+		const sourceUrl = Url.join(testDir, sourceName);
+		const destDirUrl = Url.join(testDir, destDirName);
+		const moveDirUrl = Url.join(testDir, moveDirName);
+
+		try {
+			// 1. Create source file and destination directories
+			await fs.createFile(sourceName, "file operation content");
+			await fs.createDirectory(destDirName);
+			await fs.createDirectory(moveDirName);
+
+			const sourceFs = fsOperation(sourceUrl);
+
+			// 2. copyTo
+			const copiedUrl = await sourceFs.copyTo(destDirUrl);
+			const copiedFs = fsOperation(copiedUrl);
+			test.assertEqual(
+				await copiedFs.exists(),
+				true,
+				"Copied file should exist",
+			);
+			test.assertEqual(
+				await copiedFs.readFile("utf-8"),
+				"file operation content",
+				"Copied file content should match",
+			);
+
+			// 3. moveTo
+			// Empty dir: testDir still holds the source file with the same name
+			const movedUrl = await copiedFs.moveTo(moveDirUrl);
+			const movedFs = fsOperation(movedUrl);
+			test.assertEqual(await movedFs.exists(), true, "Moved file should exist");
+			test.assertEqual(
+				await copiedFs.exists(),
+				false,
+				"Original copied file should no longer exist after move",
+			);
+			test.assertEqual(
+				await movedFs.readFile("utf-8"),
+				"file operation content",
+				"Moved file content should match",
+			);
+
+			// 4. renameTo
+			const newName = `__fs_renamed_${Date.now()}__.txt`;
+			const renamedUrl = await movedFs.renameTo(newName);
+			const renamedFs = fsOperation(renamedUrl);
+			test.assertEqual(
+				await renamedFs.exists(),
+				true,
+				"Renamed file should exist",
+			);
+			test.assertEqual(
+				await movedFs.exists(),
+				false,
+				"Original moved file should no longer exist after rename",
+			);
+			test.assertEqual(
+				await renamedFs.readFile("utf-8"),
+				"file operation content",
+				"Renamed file content should match",
+			);
+
+			// Cleanup
+			await sourceFs.delete();
+			await renamedFs.delete();
+			await fsOperation(destDirUrl).delete();
+			await fsOperation(moveDirUrl).delete();
+		} catch (error) {
+			try {
+				await fsOperation(sourceUrl).delete();
+			} catch (_) {}
+			try {
+				await fsOperation(destDirUrl).delete();
+			} catch (_) {}
+			try {
+				await fsOperation(moveDirUrl).delete();
+			} catch (_) {}
+			throw error;
+		}
+	});
+
 	return await runner.run(writeOutput);
 }

src/test/ftp.tests.js

@@ -0,0 +1,171 @@
+import fsOperation from "fileSystem";
+import Url from "utils/Url";
+import { SkipTest, TestRunner } from "./tester";
+
+export async function runFtpTests(writeOutput) {
+	const runner = new TestRunner("FTP API Tests");
+
+	const testDir = window.FTP_TEST_URL;
+
+	runner.test("FTP_TEST_URL is defined", (test) => {
+		if (!testDir) {
+			throw new SkipTest(
+				"window.FTP_TEST_URL is not defined. Set it to run FTP tests.",
+			);
+		}
+		test.assert(typeof testDir === "string", "FTP_TEST_URL should be a string");
+		test.assert(
+			testDir.startsWith("ftp://"),
+			"FTP_TEST_URL should start with ftp://",
+		);
+	});
+
+	runner.test("fsOperation returns a FileSystem object for FTP", (test) => {
+		if (!testDir) throw new SkipTest("No FTP_TEST_URL");
+		const fs = fsOperation(testDir);
+		test.assert(fs !== null, "fsOperation should return filesystem handler");
+		test.assert(
+			typeof fs.createFile === "function",
+			"createFile should be a function",
+		);
+		test.assert(typeof fs.exists === "function", "exists should be a function");
+	});
+
+	runner.test(
+		"FTP: createFile, exists, writeFile, readFile, delete",
+		async (test) => {
+			if (!testDir) throw new SkipTest("No FTP_TEST_URL");
+
+			const fs = fsOperation(testDir);
+			const filename = `__ftp_test_${Date.now()}__.txt`;
+			const fileUrl = Url.join(testDir, filename);
+
+			try {
+				// 1. Create the file
+				const createdUrl = await fs.createFile(filename, "ftp test content");
+				test.assertEqual(
+					// Provider adds default port/query to the URL; compare paths only
+					Url.pathname(createdUrl),
+					Url.pathname(fileUrl),
+					"Created file URL should match expected path",
+				);
+
+				// 2. Check existence
+				const fileFs = fsOperation(createdUrl);
+				// Native FTP exists() resolves 1/0, not a boolean
+				const exists = Boolean(await fileFs.exists());
+				test.assertEqual(exists, true, "Created file should exist on FTP");
+
+				// 3. Read content
+				const content = await fileFs.readFile("utf-8");
+				test.assertEqual(
+					content,
+					"ftp test content",
+					"Read content should match",
+				);
+
+				// 4. Write new content
+				await fileFs.writeFile("updated ftp content");
+				const updatedContent = await fileFs.readFile("utf-8");
+				test.assertEqual(
+					updatedContent,
+					"updated ftp content",
+					"Read content should match updated content",
+				);
+
+				// 5. Stat check
+				const stat = await fileFs.stat();
+				test.assert(stat !== null, "Stat should not be null");
+				test.assertEqual(stat.isFile, true, "Stat should show isFile true");
+				test.assertEqual(
+					stat.isDirectory,
+					false,
+					"Stat should show isDirectory false",
+				);
+
+				// 6. Delete file
+				await fileFs.delete();
+				const existsAfterDelete = Boolean(await fileFs.exists());
+				test.assertEqual(
+					existsAfterDelete,
+					false,
+					"File should not exist after deletion",
+				);
+			} catch (error) {
+				try {
+					const fileFs = fsOperation(fileUrl);
+					if (await fileFs.exists()) {
+						await fileFs.delete();
+					}
+				} catch (_) {}
+				throw error;
+			}
+		},
+	);
+
+	runner.test("FTP: createDirectory, lsDir, delete directory", async (test) => {
+		if (!testDir) throw new SkipTest("No FTP_TEST_URL");
+
+		const fs = fsOperation(testDir);
+		const dirname = `__ftp_dir_test_${Date.now()}__`;
+		const dirUrl = Url.join(testDir, dirname);
+
+		try {
+			// 1. Create directory
+			const createdDirUrl = await fs.createDirectory(dirname);
+			test.assertEqual(
+				Url.pathname(createdDirUrl),
+				Url.pathname(dirUrl),
+				"Created directory URL should match",
+			);
+
+			const dirFs = fsOperation(createdDirUrl);
+			// Native FTP exists() resolves 1/0, not a boolean
+			const exists = Boolean(await dirFs.exists());
+			test.assertEqual(exists, true, "Created directory should exist");
+
+			// 2. Stat check
+			const stat = await dirFs.stat();
+			test.assertEqual(
+				stat.isDirectory,
+				true,
+				"Stat should show isDirectory true",
+			);
+			test.assertEqual(stat.isFile, false, "Stat should show isFile false");
+
+			// 3. Create a file inside directory
+			const fileUrl = await dirFs.createFile("child.txt", "child content");
+
+			// 4. List directory contents
+			const list = await dirFs.lsDir();
+			const child = list.find((item) => item.name === "child.txt");
+			test.assert(
+				child !== undefined,
+				"lsDir should list the created child file",
+			);
+			test.assertEqual(child.isFile, true, "child item should be a file");
+
+			// 5. Delete child file and directory
+			const childFs = fsOperation(fileUrl);
+			await childFs.delete();
+			await dirFs.delete();
+
+			const dirExistsAfterDelete = Boolean(await dirFs.exists());
+			test.assertEqual(
+				dirExistsAfterDelete,
+				false,
+				"Directory should not exist after deletion",
+			);
+		} catch (error) {
+			try {
+				const dirFs = fsOperation(dirUrl);
+				if (await dirFs.exists()) {
+					await dirFs.delete();
+				}
+			} catch (_) {}
+			throw error;
+		}
+	});
+
+	return await runner.run(writeOutput);
+}