node: limit used nodeFs functions, fix unit tests [INT-355]

Author: perf2711

packages/node/src/BacktraceClient.ts

@@ -36,13 +36,14 @@ import { assertDatabasePath } from './database/utils.js';
 import { BacktraceStorageModule } from './storage/BacktraceStorage.js';
 import { BacktraceStorageModuleFactory } from './storage/BacktraceStorageModuleFactory.js';
 import { NodeFsBacktraceStorageModuleFactory } from './storage/NodeFsBacktraceStorage.js';
+import { NodeFs } from './storage/nodeFs.js';
 
 export class BacktraceClient extends BacktraceCoreClient<BacktraceConfiguration> {
     private _listeners: Record<string, NodeJS.UnhandledRejectionListener | NodeJS.UncaughtExceptionListener> = {};
 
     protected readonly storageFactory: BacktraceStorageModuleFactory;
     protected readonly fileAttachmentFactory: BacktraceFileAttachmentFactory;
-    protected readonly fs: typeof nodeFs;
+    protected readonly fs: NodeFs;
 
     protected get databaseNodeFsStorage() {
         return this.databaseStorage as BacktraceStorageModule | undefined;

packages/node/src/attachment/BacktraceFileAttachment.ts

@@ -2,14 +2,15 @@ import { BacktraceAttachment } from '@backtrace/sdk-core';
 import nodeFs from 'fs';
 import path from 'path';
 import { Readable } from 'stream';
+import { NodeFs } from '../storage/nodeFs.js';
 
 export class BacktraceFileAttachment implements BacktraceAttachment<Readable> {
     public readonly name: string;
 
     constructor(
         public readonly filePath: string,
         name?: string,
-        private readonly _fs: typeof nodeFs = nodeFs,
+        private readonly _fs: Pick<NodeFs, 'existsSync' | 'createReadStream'> = nodeFs,
     ) {
         this.name = name ?? path.basename(this.filePath);
     }
@@ -28,7 +29,7 @@ export interface BacktraceFileAttachmentFactory {
 }
 
 export class NodeFsBacktraceFileAttachmentFactory implements BacktraceFileAttachmentFactory {
-    constructor(private readonly _fs: typeof nodeFs = nodeFs) {}
+    constructor(private readonly _fs: Pick<NodeFs, 'existsSync' | 'createReadStream'> = nodeFs) {}
 
     public create(filePath: string, name?: string): BacktraceFileAttachment {
         return new BacktraceFileAttachment(filePath, name, this._fs);

packages/node/src/builder/BacktraceClientSetup.ts

@@ -1,15 +1,15 @@
 import { PartialCoreClientSetup } from '@backtrace/sdk-core';
-import nodeFs from 'fs';
 import { BacktraceSetupConfiguration } from '../BacktraceConfiguration.js';
 import { BacktraceStorageModule } from '../storage/BacktraceStorage.js';
 import { BacktraceStorageModuleFactory } from '../storage/BacktraceStorageModuleFactory.js';
+import { NodeFs } from '../storage/nodeFs.js';
 
 export interface BacktraceClientSetup extends PartialCoreClientSetup<'sdkOptions' | 'requestHandler'> {}
 
 export type BacktraceNodeClientSetup = Omit<BacktraceClientSetup, 'options' | 'database'> & {
     readonly options: BacktraceSetupConfiguration;
     readonly storageFactory?: BacktraceStorageModuleFactory;
-    readonly fs?: typeof nodeFs;
+    readonly fs?: NodeFs;
     readonly database?: Omit<NonNullable<BacktraceClientSetup['database']>, 'storage'> & {
         readonly storage?: BacktraceStorageModule;
     };

packages/node/src/storage/BacktraceStorage.ts

@@ -1,6 +1,7 @@
 import { BacktraceStorageModule as CoreBacktraceStorageModule } from '@backtrace/sdk-core';
 import nodeFs from 'fs';
 import { BacktraceConfiguration } from '../BacktraceConfiguration.js';
+import { NodeFs } from './nodeFs.js';
 
 export interface ReadonlyBacktraceStreamStorage {
     createReadStream(key: string): nodeFs.ReadStream;
@@ -15,5 +16,5 @@ export type BacktraceStorageModule = CoreBacktraceStorageModule<BacktraceConfigu
 export interface BacktraceStorageModuleOptions {
     readonly path: string;
     readonly createDirectory?: boolean;
-    readonly fs?: typeof nodeFs;
+    readonly fs?: NodeFs;
 }

packages/node/src/storage/NodeFsBacktraceStorage.ts

@@ -2,10 +2,11 @@ import nodeFs from 'fs';
 import path from 'path';
 import { BacktraceStorageModule, BacktraceStorageModuleOptions } from './BacktraceStorage.js';
 import { BacktraceStorageModuleFactory } from './BacktraceStorageModuleFactory.js';
+import { NodeFs } from './nodeFs.js';
 
 export class NodeFsBacktraceStorage implements BacktraceStorageModule {
     private readonly _path: string;
-    private readonly _fs: typeof nodeFs;
+    private readonly _fs: NodeFs;
     private readonly _createDirectory: boolean;
 
     constructor(options: BacktraceStorageModuleOptions) {
@@ -115,11 +116,11 @@ export class NodeFsBacktraceStorage implements BacktraceStorageModule {
     }
 
     public createWriteStream(key: string): nodeFs.WriteStream {
-        return nodeFs.createWriteStream(this.resolvePath(key), 'utf-8');
+        return this._fs.createWriteStream(this.resolvePath(key), 'utf-8');
     }
 
     public createReadStream(key: string): nodeFs.ReadStream {
-        return nodeFs.createReadStream(this.resolvePath(key), 'utf-8');
+        return this._fs.createReadStream(this.resolvePath(key), 'utf-8');
     }
 
     protected resolvePath(key: string) {

packages/node/src/storage/nodeFs.ts

@@ -0,0 +1,19 @@
+import nodeFs from 'fs';
+
+/**
+ * All used methods of the Node file system.
+ */
+export type NodeFs = Pick<
+    typeof nodeFs,
+    | 'mkdirSync'
+    | 'existsSync'
+    | 'writeFileSync'
+    | 'unlinkSync'
+    | 'readFileSync'
+    | 'statSync'
+    | 'readdirSync'
+    | 'createReadStream'
+    | 'createWriteStream'
+> & {
+    readonly promises: Pick<(typeof nodeFs)['promises'], 'readdir' | 'stat' | 'writeFile' | 'unlink' | 'readFile'>;
+};

packages/node/tests/_mocks/storage.ts

@@ -1,20 +1,25 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore The following import fails due to missing extension, but it cannot have one (it imports a .ts file)
 import { mockBacktraceStorage } from '@backtrace/sdk-core/tests/_mocks/storage';
+
+import { BacktraceStorageModule } from '@backtrace/sdk-core';
 import type { MockedBacktraceStorage } from '@backtrace/sdk-core/tests/_mocks/storage.js';
 import { ReadStream, WriteStream } from 'fs';
 import { Readable, Writable } from 'stream';
 import { NodeFsBacktraceStorage } from '../../src/storage/NodeFsBacktraceStorage.js';
+import { NodeFs } from '../../src/storage/nodeFs.js';
+
+type MockedFs = Pick<NodeFs, 'existsSync' | 'createReadStream'>;
 
-export function mockStreamFileSystem(
+export function mockNodeStorageAndFs(
     files?: Record<string, string>,
-): MockedBacktraceStorage<Omit<NodeFsBacktraceStorage, 'fs' | 'initialize'>> {
-    const fs = mockBacktraceStorage(files);
+): MockedBacktraceStorage<Omit<NodeFsBacktraceStorage & MockedFs, 'fs' | 'initialize'>> {
+    const storage = mockBacktraceStorage(files) as MockedBacktraceStorage<Omit<BacktraceStorageModule, 'bind'>>;
 
     return {
-        ...fs,
+        ...storage,
 
-        ofPath: jest.fn().mockImplementation(() => mockStreamFileSystem()),
+        existsSync: jest.fn().mockImplementation((p: string) => p in storage.files),
 
         createWriteStream: jest.fn().mockImplementation((p: string) => {
             const writable = new Writable({
@@ -25,10 +30,10 @@ export function mockStreamFileSystem(
                           ? chunk
                           : String(chunk).toString();
 
-                    if (!fs.files[p]) {
-                        fs.files[p] = str;
+                    if (!storage.files[p]) {
+                        storage.files[p] = str;
                     } else {
-                        fs.files[p] += str;
+                        storage.files[p] += str;
                     }
 
                     callback && callback();
@@ -39,7 +44,7 @@ export function mockStreamFileSystem(
         }),
 
         createReadStream: jest.fn().mockImplementation((p: string) => {
-            const file = fs.files[p];
+            const file = storage.files[p];
             if (!file) {
                 throw new Error(`File ${p} does not exist`);
             }

packages/node/tests/breadcrumbs/FileBreadcrumbsStorage.spec.ts

@@ -3,7 +3,8 @@ import assert from 'assert';
 import { Readable } from 'stream';
 import { promisify } from 'util';
 import { FileBreadcrumbsStorage } from '../../src/breadcrumbs/FileBreadcrumbsStorage.js';
-import { mockStreamFileSystem } from '../_mocks/storage.js';
+import { NodeFsBacktraceFileAttachmentFactory } from '../../src/index.js';
+import { mockNodeStorageAndFs } from '../_mocks/storage.js';
 
 async function readToEnd(readable: Readable) {
     return new Promise<Buffer>((resolve, reject) => {
@@ -33,8 +34,8 @@ const nextTick = promisify(process.nextTick);
 
 describe('FileBreadcrumbsStorage', () => {
     it('should return added breadcrumbs', async () => {
-        const fs = mockStreamFileSystem();
-        const session = new SessionFiles(fs, 'sessionId');
+        const fs = mockNodeStorageAndFs();
+        const session = new SessionFiles(fs, { id: 'sessionId', timestamp: Date.now() });
 
         const breadcrumbs: RawBreadcrumb[] = [
             {
@@ -86,7 +87,7 @@ describe('FileBreadcrumbsStorage', () => {
             },
         ];
 
-        const storage = new FileBreadcrumbsStorage(session, fs, {
+        const storage = new FileBreadcrumbsStorage(session, fs, new NodeFsBacktraceFileAttachmentFactory(fs), {
             maximumBreadcrumbs: 100,
         });
 
@@ -107,8 +108,8 @@ describe('FileBreadcrumbsStorage', () => {
     });
 
     it('should return added breadcrumbs in two attachments', async () => {
-        const fs = mockStreamFileSystem();
-        const session = new SessionFiles(fs, 'sessionId');
+        const fs = mockNodeStorageAndFs();
+        const session = new SessionFiles(fs, { id: 'sessionId', timestamp: Date.now() });
 
         const breadcrumbs: RawBreadcrumb[] = [
             {
@@ -163,7 +164,7 @@ describe('FileBreadcrumbsStorage', () => {
             },
         ];
 
-        const storage = new FileBreadcrumbsStorage(session, fs, {
+        const storage = new FileBreadcrumbsStorage(session, fs, new NodeFsBacktraceFileAttachmentFactory(fs), {
             maximumBreadcrumbs: 4,
         });
 
@@ -189,8 +190,8 @@ describe('FileBreadcrumbsStorage', () => {
     });
 
     it('should return no more than maximumBreadcrumbs breadcrumbs', async () => {
-        const fs = mockStreamFileSystem();
-        const session = new SessionFiles(fs, 'sessionId');
+        const fs = mockNodeStorageAndFs();
+        const session = new SessionFiles(fs, { id: 'sessionId', timestamp: Date.now() });
 
         const breadcrumbs: RawBreadcrumb[] = [
             {
@@ -235,7 +236,7 @@ describe('FileBreadcrumbsStorage', () => {
             },
         ];
 
-        const storage = new FileBreadcrumbsStorage(session, fs, {
+        const storage = new FileBreadcrumbsStorage(session, fs, new NodeFsBacktraceFileAttachmentFactory(fs), {
             maximumBreadcrumbs: 2,
         });
 
@@ -261,8 +262,8 @@ describe('FileBreadcrumbsStorage', () => {
     });
 
     it('should return breadcrumbs up to the json size', async () => {
-        const fs = mockStreamFileSystem();
-        const session = new SessionFiles(fs, 'sessionId');
+        const fs = mockNodeStorageAndFs();
+        const session = new SessionFiles(fs, { id: 'sessionId', timestamp: Date.now() });
 
         const breadcrumbs: RawBreadcrumb[] = [
             {
@@ -302,7 +303,7 @@ describe('FileBreadcrumbsStorage', () => {
             },
         ];
 
-        const storage = new FileBreadcrumbsStorage(session, fs, {
+        const storage = new FileBreadcrumbsStorage(session, fs, new NodeFsBacktraceFileAttachmentFactory(fs), {
             maximumBreadcrumbs: 100,
             maximumTotalBreadcrumbsSize: JSON.stringify(expectedMain[0]).length + 10,
         });
@@ -329,8 +330,8 @@ describe('FileBreadcrumbsStorage', () => {
     });
 
     it('should return attachments with a valid name from getAttachments', async () => {
-        const fs = mockStreamFileSystem();
-        const session = new SessionFiles(fs, 'sessionId');
+        const fs = mockNodeStorageAndFs();
+        const session = new SessionFiles(fs, { id: 'sessionId', timestamp: Date.now() });
 
         const breadcrumbs: RawBreadcrumb[] = [
             {
@@ -354,7 +355,7 @@ describe('FileBreadcrumbsStorage', () => {
             },
         ];
 
-        const storage = new FileBreadcrumbsStorage(session, fs, {
+        const storage = new FileBreadcrumbsStorage(session, fs, new NodeFsBacktraceFileAttachmentFactory(fs), {
             maximumBreadcrumbs: 4,
         });
 
@@ -373,8 +374,8 @@ describe('FileBreadcrumbsStorage', () => {
     });
 
     it('should return attachments with a valid name from getAttachmentProviders', async () => {
-        const fs = mockStreamFileSystem();
-        const session = new SessionFiles(fs, 'sessionId');
+        const fs = mockNodeStorageAndFs();
+        const session = new SessionFiles(fs, { id: 'sessionId', timestamp: Date.now() });
 
         const breadcrumbs: RawBreadcrumb[] = [
             {
@@ -398,7 +399,7 @@ describe('FileBreadcrumbsStorage', () => {
             },
         ];
 
-        const storage = new FileBreadcrumbsStorage(session, fs, {
+        const storage = new FileBreadcrumbsStorage(session, fs, new NodeFsBacktraceFileAttachmentFactory(fs), {
             maximumBreadcrumbs: 4,
         });
 

packages/node/tests/streams/fileChunkSink.spec.ts

@@ -1,6 +1,6 @@
 import { Writable } from 'stream';
 import { FileChunkSink } from '../../src/streams/fileChunkSink.js';
-import { mockStreamFileSystem } from '../_mocks/storage.js';
+import { mockNodeStorageAndFs } from '../_mocks/storage.js';
 
 function writeAndClose(stream: Writable, value: string) {
     return new Promise((resolve, reject) => {
@@ -17,7 +17,7 @@ function sortString(a: string, b: string) {
 
 describe('fileChunkSink', () => {
     it('should create a filestream with name from filename', async () => {
-        const fs = mockStreamFileSystem();
+        const fs = mockNodeStorageAndFs();
         const filename = 'abc';
         const sink = new FileChunkSink({ file: () => filename, maxFiles: Infinity, storage: fs });
 
@@ -26,7 +26,7 @@ describe('fileChunkSink', () => {
     });
 
     it('should create a filestream each time it is called', async () => {
-        const fs = mockStreamFileSystem();
+        const fs = mockNodeStorageAndFs();
         const sink = new FileChunkSink({ file: (n) => n.toString(), maxFiles: Infinity, storage: fs });
         const expected = [0, 2, 5];
 
@@ -40,7 +40,7 @@ describe('fileChunkSink', () => {
     });
 
     it('should remove previous files if count exceeds maxFiles', async () => {
-        const fs = mockStreamFileSystem();
+        const fs = mockNodeStorageAndFs();
         const maxFiles = 3;
         const sink = new FileChunkSink({ file: (n) => n.toString(), maxFiles, storage: fs });
         const files = [0, 2, 5, 6, 79, 81, 38, -1, 3];