Refactor tests

frontend/sync-client/src/index.ts

@@ -2,6 +2,7 @@ import { awaitAll } from "./utils/await-all";
 import { logToConsole } from "./utils/debugging/log-to-console";
 import { slowFetchFactory } from "./utils/debugging/slow-fetch-factory";
 import { slowWebSocketFactory } from "./utils/debugging/slow-web-socket-factory";
+import { InMemoryFileSystem } from "./utils/debugging/in-memory-file-system";
 import { getRandomColor } from "./utils/get-random-color";
 import { lineAndColumnToPosition } from "./utils/line-and-column-to-position";
 import { positionToLineAndColumn } from "./utils/position-to-line-and-column";
@@ -37,7 +38,8 @@ export type { TextWithCursors, CursorPosition } from "reconcile-text";
 export const debugging = {
     slowFetchFactory,
     slowWebSocketFactory,
-    logToConsole
+    logToConsole,
+    InMemoryFileSystem
 };
 
 export const utils = {

frontend/sync-client/src/sync-operations/unrestricted-syncer.ts

@@ -74,12 +74,6 @@ export class UnrestrictedSyncer {
         force?: boolean;
         document: DocumentRecord;
     }): Promise<void> {
-        // this.history.addHistoryEntry({
-        //     status: SyncStatus.SUCCESS,
-        //     details: updateDetails,
-        //     message: `Successfully uploaded locally created file`
-        // });
-
         const updateDetails:
             | SyncCreateDetails
             | SyncUpdateDetails
@@ -221,15 +215,6 @@ export class UnrestrictedSyncer {
                           relativePath: response.relativePath
                       };
 
-            // if (areThereLocalChanges) {
-            //     this.history.addHistoryEntry({
-            //         status: SyncStatus.SUCCESS,
-            //         details: actualUpdateDetails,
-            //         message: `Successfully uploaded locally updated file to the server`,
-            //         author: response.userId
-            //     });
-            // } else
-
             if (!response.isDeleted) {
                 this.history.addHistoryEntry({
                     status: SyncStatus.SUCCESS,
@@ -246,7 +231,7 @@ export class UnrestrictedSyncer {
                         relativePath: document.relativePath
                     },
                     message:
-                        "File has been deleted remotely, so we deleted it locally",
+                        "Successfully deleted file which had been deleted remotely",
                     author: response.userId,
                     timestamp: new Date(response.updatedDate)
                 });

frontend/sync-client/src/utils/debugging/in-memory-file-system.ts

@@ -0,0 +1,70 @@
+import type { RelativePath } from "../../persistence/database";
+import type { TextWithCursors } from "reconcile-text";
+import type { FileSystemOperations } from "../../file-operations/filesystem-operations";
+
+export class InMemoryFileSystem implements FileSystemOperations {
+    protected readonly files = new Map<string, Uint8Array>();
+
+    public async listFilesRecursively(
+        _root: RelativePath | undefined = undefined // we don't use multi-level paths during tests
+    ): Promise<RelativePath[]> {
+        return Array.from(this.files.keys());
+    }
+
+    public async read(path: RelativePath): Promise<Uint8Array> {
+        const file = this.files.get(path);
+        if (!file) {
+            throw new Error(`File ${path} does not exist`);
+        }
+        return file;
+    }
+
+    public async write(path: RelativePath, content: Uint8Array): Promise<void> {
+        this.files.set(path, content);
+    }
+
+    public async atomicUpdateText(
+        path: RelativePath,
+        updater: (current: TextWithCursors) => TextWithCursors
+    ): Promise<string> {
+        const file = this.files.get(path);
+        if (!file) {
+            throw new Error(`File ${path} does not exist`);
+        }
+        const currentContent = new TextDecoder().decode(file);
+        const newContent = updater({ text: currentContent, cursors: [] }).text;
+        this.files.set(path, new TextEncoder().encode(newContent));
+        return newContent;
+    }
+
+    public async getFileSize(path: RelativePath): Promise<number> {
+        return (await this.read(path)).length;
+    }
+
+    public async exists(path: RelativePath): Promise<boolean> {
+        return this.files.has(path);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    public async createDirectory(_path: RelativePath): Promise<void> {
+        // This doesn't mean anything in our virtual FS representation
+    }
+
+    public async delete(path: RelativePath): Promise<void> {
+        this.files.delete(path);
+    }
+
+    public async rename(
+        oldPath: RelativePath,
+        newPath: RelativePath
+    ): Promise<void> {
+        const file = this.files.get(oldPath);
+        if (!file) {
+            throw new Error(`File ${oldPath} does not exist`);
+        }
+        this.files.set(newPath, file);
+        if (oldPath !== newPath) {
+            this.files.delete(oldPath);
+        }
+    }
+}

frontend/sync-client/src/utils/debugging/log-to-console.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import type { Logger, LogLine } from "../../tracing/logger";
 import { LogLevel } from "../../tracing/logger";