test: refactor tests to avoid mocks

Author: Hweinstock

packages/core/src/codewhisperer/util/zipUtil.ts

@@ -23,6 +23,7 @@ import { getTextContent } from '../../shared/utilities/textDocumentUtilities'
 import { ChildProcess, ChildProcessOptions } from '../../shared/utilities/processUtils'
 import { removeAnsi } from '../../shared/utilities/textUtilities'
 import { isFileOpenAndDirty } from '../../shared/utilities/vsCodeUtils'
+import { ToolkitError } from '../../shared/errors'
 
 export interface ZipMetadata {
     rootDir: string
@@ -51,6 +52,7 @@ export const ZipConstants = {
 }
 
 type ZipType = 'file' | 'project'
+type PayloadLimits = Record<ZipType, number>
 
 export class ZipUtil {
     protected _pickedSourceFiles: Set<string> = new Set<string>()
@@ -63,18 +65,23 @@ export class ZipUtil {
     protected _fetchedDirs: Set<string> = new Set<string>()
     protected _language: CodewhispererLanguage | undefined
     protected _timestamp: string = Date.now().toString()
-    protected static _payloadByteLimits = {
-        file: CodeWhispererConstants.fileScanPayloadSizeLimitBytes,
-        project: CodeWhispererConstants.projectScanPayloadSizeLimitBytes,
+    protected _payloadByteLimits: PayloadLimits
+    constructor(
+        protected _zipDirPrefix: string,
+        payloadLimits?: PayloadLimits
+    ) {
+        this._payloadByteLimits = payloadLimits ?? {
+            file: CodeWhispererConstants.fileScanPayloadSizeLimitBytes,
+            project: CodeWhispererConstants.projectScanPayloadSizeLimitBytes,
+        }
     }
-    constructor(protected _zipDirPrefix: string) {}
 
-    public static aboveByteLimit(size: number, limitType: ZipType): boolean {
+    public aboveByteLimit(size: number, limitType: ZipType): boolean {
         return size > this._payloadByteLimits[limitType]
     }
 
-    public static willReachProjectByteLimit(current: number, adding: number): boolean {
-        return ZipUtil.aboveByteLimit(current + adding, 'project')
+    public willReachProjectByteLimit(current: number, adding: number): boolean {
+        return this.aboveByteLimit(current + adding, 'project')
     }
 
     public async zipFile(uri: vscode.Uri | undefined, includeGitDiffHeader?: boolean) {
@@ -107,7 +114,7 @@ export class ZipUtil {
         this._totalSize += (await fs.stat(uri.fsPath)).size
         this._totalLines += content.split(ZipConstants.newlineRegex).length
 
-        if (ZipUtil.aboveByteLimit(this._totalSize, 'file')) {
+        if (this.aboveByteLimit(this._totalSize, 'file')) {
             throw new FileSizeExceededError()
         }
         const zipDirPath = this.getZipDirPath()
@@ -226,10 +233,15 @@ export class ZipUtil {
         if (!projectPaths || projectPaths.length === 0) {
             return
         }
-
         const sourceFiles = await collectFiles(projectPaths, workspaceFolders, {
-            maxTotalSizeBytes: ZipUtil._payloadByteLimits['project'],
+            maxTotalSizeBytes: this._payloadByteLimits['project'],
             excludePatterns,
+        }).catch((e) => {
+            // Check if project is too large to collect.
+            if (e instanceof ToolkitError && e.code === 'ContentLengthError') {
+                throw new ProjectSizeExceededError()
+            }
+            throw e
         })
         for (const file of sourceFiles) {
             const projectName = path.basename(file.workspaceFolder.uri.fsPath)
@@ -263,8 +275,8 @@ export class ZipUtil {
         const fileSize = Buffer.from(fileContent).length
 
         if (
-            ZipUtil.aboveByteLimit(this._totalSize, 'project') ||
-            ZipUtil.willReachProjectByteLimit(this._totalSize, fileSize)
+            this.aboveByteLimit(this._totalSize, 'project') ||
+            this.willReachProjectByteLimit(this._totalSize, fileSize)
         ) {
             throw new ProjectSizeExceededError()
         }
@@ -280,8 +292,8 @@ export class ZipUtil {
         const fileSize = (await fs.stat(uri.fsPath)).size
 
         if (
-            ZipUtil.aboveByteLimit(this._totalSize, 'project') ||
-            ZipUtil.willReachProjectByteLimit(this._totalSize, fileSize)
+            this.aboveByteLimit(this._totalSize, 'project') ||
+            this.willReachProjectByteLimit(this._totalSize, fileSize)
         ) {
             throw new ProjectSizeExceededError()
         }

packages/core/src/test/codewhisperer/zipUtil.test.ts

@@ -6,7 +6,6 @@
 import assert from 'assert'
 import vscode from 'vscode'
 import path from 'path'
-import sinon from 'sinon'
 import { join } from 'path'
 import JSZip from 'jszip'
 import { getTestWorkspaceFolder } from '../../testInteg/integrationTestsUtilities'
@@ -30,40 +29,36 @@ describe('zipUtil', function () {
         zipUtil = new ZipUtil(CodeWhispererConstants.codeScanTruncDirPrefix)
     })
 
-    afterEach(function () {
-        sinon.restore()
-    })
-
-    it('returns the proper size limit for zip', function () {
+    it('defaults to proper size limits for zip', function () {
         assert.strictEqual(
-            ZipUtil.aboveByteLimit(CodeWhispererConstants.fileScanPayloadSizeLimitBytes + 1, 'file'),
+            zipUtil.aboveByteLimit(CodeWhispererConstants.fileScanPayloadSizeLimitBytes + 1, 'file'),
             true
         )
 
         assert.strictEqual(
-            ZipUtil.aboveByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes + 1, 'project'),
+            zipUtil.aboveByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes + 1, 'project'),
             true
         )
 
         assert.strictEqual(
-            ZipUtil.aboveByteLimit(CodeWhispererConstants.fileScanPayloadSizeLimitBytes - 1, 'file'),
+            zipUtil.aboveByteLimit(CodeWhispererConstants.fileScanPayloadSizeLimitBytes - 1, 'file'),
             false
         )
 
         assert.strictEqual(
-            ZipUtil.aboveByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes - 1, 'project'),
+            zipUtil.aboveByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes - 1, 'project'),
             false
         )
     })
 
     it('determines if adding file will exceed project byte limit', function () {
         assert.strictEqual(
-            ZipUtil.willReachProjectByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes, 1),
+            zipUtil.willReachProjectByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes, 1),
             true
         )
 
         assert.strictEqual(
-            ZipUtil.willReachProjectByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes - 10, 9),
+            zipUtil.willReachProjectByteLimit(CodeWhispererConstants.projectScanPayloadSizeLimitBytes - 10, 9),
             false
         )
     })
@@ -94,33 +89,44 @@ describe('zipUtil', function () {
     })
 
     it('throws error if payload size limit is reached for file', async function () {
-        sinon.stub(ZipUtil, 'aboveByteLimit').returns(true)
-
+        const limitedZipUtil = new ZipUtil(CodeWhispererConstants.codeScanTruncDirPrefix, {
+            file: 1,
+            project: 1,
+        })
         await assert.rejects(
-            () => zipUtil.zipFile(vscode.Uri.file(appCodePath), true),
+            () => limitedZipUtil.zipFile(vscode.Uri.file(appCodePath), true),
             new ToolkitError(`Payload size limit reached`, { code: 'FileSizeExceeded' })
         )
     })
 
     it('throws error if payload size limit is reached for project', async function () {
-        sinon.stub(ZipUtil, 'aboveByteLimit').returns(true)
-
+        const testWorkspace = await TestFolder.create()
+        await testWorkspace.write('afile.py', '12345')
+        const limitedZipUtil = new ZipUtil(CodeWhispererConstants.codeScanTruncDirPrefix, {
+            file: 1,
+            project: 4,
+        })
         await assert.rejects(
             () =>
-                zipUtil.zipProject(
-                    [...(vscode.workspace.workspaceFolders ?? [])] as CurrentWsFolders,
-                    defaultExcludePatterns
+                limitedZipUtil.zipProject(
+                    [{ uri: vscode.Uri.parse(testWorkspace.path), name: 'testWorkspace', index: 0 }],
+                    defaultExcludePatterns,
+                    {
+                        projectPath: testWorkspace.path,
+                    }
                 ),
             new ToolkitError('Payload size limit reached', { code: 'ProjectSizeExceeded' })
         )
     })
 
     it('throws error if payload size limit will be reached for project', async function () {
-        sinon.stub(ZipUtil, 'willReachProjectByteLimit').returns(true)
-
+        const limitedZipUtil = new ZipUtil(CodeWhispererConstants.codeScanTruncDirPrefix, {
+            file: 1,
+            project: 1,
+        })
         await assert.rejects(
             () =>
-                zipUtil.zipProject(
+                limitedZipUtil.zipProject(
                     [...(vscode.workspace.workspaceFolders ?? [])] as CurrentWsFolders,
                     defaultExcludePatterns
                 ),
@@ -255,10 +261,7 @@ describe('zipUtil', function () {
             async () =>
                 await zipUtil.zipProject(
                     [{ uri: vscode.Uri.file(project.path), name: 'project1', index: 0 }] as CurrentWsFolders,
-                    defaultExcludePatterns,
-                    {
-                        includeNonWorkspaceFiles: true,
-                    }
+                    defaultExcludePatterns
                 ),
             new NoSourceFilesError()
         )