clean-slate when dry-run is enabled + tests

Author: SamKirkland

Diff for: src/deploy.ts

@@ -66,17 +66,19 @@ async function connect(client: ftp.Client, args: IFtpDeployArgumentsWithDefaults
     }
 }
 
-async function getServerFiles(client: ftp.Client, logger: ILogger, timings: ITimings, args: IFtpDeployArgumentsWithDefaults): Promise<IFileList> {
+export async function getServerFiles(client: ftp.Client, logger: ILogger, timings: ITimings, args: IFtpDeployArgumentsWithDefaults): Promise<IFileList> {
     try {
         await ensureDir(client, logger, timings, args["server-dir"]);
 
         if (args["dangerous-clean-slate"]) {
             logger.all(`----------------------------------------------------------------`);
             logger.all("🗑️ Removing all files on the server because 'dangerous-clean-slate' was set, this will make the deployment very slow...");
-            await client.clearWorkingDir();
+            if (args["dry-run"] === false) {
+                await client.clearWorkingDir();
+            }
             logger.all("Clear complete");
 
-            throw new Error("nope");
+            throw new Error("dangerous-clean-slate was run");
         }
 
         const serverFiles = await downloadFileList(client, logger, args["state-name"]);

Diff for: src/main.test.ts

@@ -1,12 +1,12 @@
 import { HashDiff } from "./HashDiff";
-import { IFileList, currentSyncFileVersion, IFile, IFtpDeployArgumentsWithDefaults } from "./types";
+import { IFileList, currentSyncFileVersion, IFile, IFtpDeployArgumentsWithDefaults, DiffResult } from "./types";
 import { Record } from "./types";
 import { applyExcludeFilter, getDefaultSettings, ILogger, Timings } from "./utilities";
 import path from "path";
 import FtpSrv from "ftp-srv";
 import { getLocalFiles } from "./localFiles";
 import { FTPSyncProvider } from "./syncProvider";
-import { deploy } from "./deploy";
+import { deploy, getServerFiles } from "./deploy";
 import { Stats as readdirStats } from "@jsdevtools/readdir-enhanced";
 import { excludeDefaults } from "./module";
 
@@ -787,6 +787,91 @@ describe("error handling", () => {
     }, 30000);
 });
 
+describe("dry-run", () => {
+    test("getServerFiles doesn't mutate server", async () => {
+        const mockedLogger = new MockedLogger();
+        const mockedTimings = new Timings();
+        const mockClient = {
+            clearWorkingDir() { },
+            ensureDir() { },
+        };
+        const settings = getDefaultSettings({
+            server: "a",
+            username: "b",
+            password: "c",
+            "dry-run": true,
+            "dangerous-clean-slate": true,
+        });
+
+        const spyClearWorkingDir = jest.spyOn(mockClient, "clearWorkingDir");
+        await getServerFiles(mockClient as any, mockedLogger, mockedTimings, settings);
+
+        expect(spyClearWorkingDir).toHaveBeenCalledTimes(0);
+    });
+
+    test("doesn't mutate server", async () => {
+        const mockedLogger = new MockedLogger();
+        const mockedTimings = new Timings();
+        const mockClient = {
+            uploadFile() { },
+            removeFile() { },
+            uploadFrom() { },
+            remove() { },
+        };
+        const mockedDiffs: DiffResult = {
+            upload: [
+                {
+                    type: "file",
+                    name: "path/upload.txt",
+                    size: 1000,
+                    hash: "hash2",
+                }
+            ],
+            delete: [
+                {
+                    type: "file",
+                    name: "path/delete.txt",
+                    size: 1000,
+                    hash: "hash2",
+                }
+            ],
+            replace: [
+                {
+                    type: "file",
+                    name: "path/replace.txt",
+                    size: 1000,
+                    hash: "hash2",
+                }
+            ],
+            same: [
+                {
+                    type: "file",
+                    name: "path/same.txt",
+                    size: 1000,
+                    hash: "hash2",
+                }
+            ],
+            sizeUpload: 1000,
+            sizeDelete: 1000,
+            sizeReplace: 1000,
+        };
+
+        // todo ensureDir
+
+        const syncProvider = new FTPSyncProvider(mockClient as any, mockedLogger, mockedTimings, "local-dir/", "server-dir/", "state-name", true);
+        const spyUploadFile = jest.spyOn(mockClient, "uploadFile");
+        const spyRemoveFile = jest.spyOn(mockClient, "removeFile");
+        const spyUploadFrom = jest.spyOn(mockClient, "uploadFrom");
+        const spyRemove = jest.spyOn(mockClient, "remove");
+        await syncProvider.syncLocalToServer(mockedDiffs);
+
+        expect(spyUploadFile).toHaveBeenCalledTimes(0);
+        expect(spyRemoveFile).toHaveBeenCalledTimes(0);
+        expect(spyUploadFrom).toHaveBeenCalledTimes(0);
+        expect(spyRemove).toHaveBeenCalledTimes(0);
+    });
+});
+
 describe("Deploy", () => {
     const port = 2121;
     const homeDir = path.join(__dirname, "../");