refactor textUtilities tests

Author: Hweinstock

packages/core/src/amazonq/commons/controllers/contentController.ts

@@ -15,7 +15,13 @@ import {
     getIndentedCode,
     getSelectionFromRange,
 } from '../../../shared/utilities/textDocumentUtilities'
-import { extractFileAndCodeSelectionFromMessage, fs, getErrorMsg, ToolkitError } from '../../../shared'
+import {
+    extractFileAndCodeSelectionFromMessage,
+    formatTextWithIndent,
+    fs,
+    getErrorMsg,
+    ToolkitError,
+} from '../../../shared'
 
 export class ContentProvider implements vscode.TextDocumentContentProvider {
     constructor(private uri: vscode.Uri) {}
@@ -49,14 +55,7 @@ export class EditorContentController {
             if (indent.trim().length !== 0) {
                 indent = ' '.repeat(indent.length - indent.trimStart().length)
             }
-            let textWithIndent = ''
-            text.split('\n').forEach((line, index) => {
-                if (index === 0) {
-                    textWithIndent += line
-                } else {
-                    textWithIndent += '\n' + indent + line
-                }
-            })
+            const textWithIndent = formatTextWithIndent(text, indent)
             editor
                 .edit((editBuilder) => {
                     editBuilder.insert(cursorStart, textWithIndent)

packages/core/src/amazonq/commons/diff.ts

@@ -5,7 +5,7 @@
 
 import * as vscode from 'vscode'
 import { fs } from '../../shared'
-import { diffLines } from 'diff'
+import { Change, diffLines } from 'diff'
 
 export async function openDiff(leftPath: string, rightPath: string, tabId: string, scheme: string) {
     const { left, right } = await getFileDiffUris(leftPath, rightPath, tabId, scheme)
@@ -42,21 +42,30 @@ export async function computeDiff(leftPath: string, rightPath: string, tabId: st
         ignoreWhitespace: true,
     })
 
-    let charsAdded = 0
-    let charsRemoved = 0
-    let linesAdded = 0
-    let linesRemoved = 0
-    changes.forEach((change) => {
-        const lines = change.value.split('\n')
-        const charCount = lines.reduce((sum, line) => sum + line.length, 0)
-        const lineCount = change.count ?? lines.length - 1 // ignoring end-of-file empty line
-        if (change.added) {
-            charsAdded += charCount
-            linesAdded += lineCount
-        } else if (change.removed) {
-            charsRemoved += charCount
-            linesRemoved += lineCount
-        }
-    })
-    return { changes, charsAdded, linesAdded, charsRemoved, linesRemoved }
+    interface Result {
+        charsAdded: number
+        linesAdded: number
+        charsRemoved: number
+        linesRemoved: number
+    }
+
+    const changeDetails = changes.reduce(
+        (curResult: Result, change: Change) => {
+            const lines = change.value.split('\n')
+            const charCount = lines.reduce((sum, line) => sum + line.length, 0)
+            const lineCount = change.count ?? lines.length - 1 // ignoring end-of-file empty line
+
+            if (change.added) {
+                curResult.charsAdded += charCount
+                curResult.linesAdded += lineCount
+            } else if (change.removed) {
+                curResult.charsRemoved += charCount
+                curResult.linesRemoved += lineCount
+            }
+            return curResult
+        },
+        { charsAdded: 0, linesAdded: 0, charsRemoved: 0, linesRemoved: 0 }
+    )
+
+    return { changes, ...changeDetails }
 }

packages/core/src/shared/utilities/collectionUtils.ts

@@ -346,13 +346,13 @@ export function inspect(obj: any, opt?: { depth: number }): string {
 export function stripUndefined<T extends Record<string, any>>(
     obj: T
 ): asserts obj is { [P in keyof T]-?: NonNullable<T[P]> } {
-    Object.keys(obj).forEach((key) => {
+    for (const key of Object.keys(obj)) {
         if (obj[key] === undefined) {
             delete obj[key]
         } else if (typeof obj[key] === 'object') {
             stripUndefined(obj[key])
         }
-    })
+    }
 }
 
 export function isAsyncIterable(obj: any): obj is AsyncIterable<unknown> {

packages/core/src/shared/utilities/textUtilities.ts

@@ -274,3 +274,8 @@ export function extractFileAndCodeSelectionFromMessage(message: any) {
     const selection = message?.context?.focusAreaContext?.selectionInsideExtendedCodeBlock as vscode.Selection
     return { filePath, selection }
 }
+
+export function formatTextWithIndent(text: string, indent: string): string {
+    // TODO: shouldn't this trim the resulting string?
+    return text.split('\n').reduce((prev, curr) => (prev === '' ? prev + curr : prev + '\n' + indent + curr))
+}

packages/core/src/test/shared/utilities/textUtilities.test.ts

@@ -13,6 +13,8 @@ import {
     sanitizeFilename,
     toSnakeCase,
     undefinedIfEmpty,
+    formatTextWithIndent,
+    formatTextWithIndent2,
 } from '../../../shared/utilities/textUtilities'
 
 describe('textUtilities', async function () {
@@ -131,21 +133,35 @@ describe('toSnakeCase', function () {
     })
 })
 
+interface TestCase<Input, Output> {
+    input: Input
+    params?: any[]
+    output: Output
+    case: string
+}
+
+function generateTestCases<Input, Output>(
+    cases: TestCase<Input, Output>[],
+    f: (t: Input, ...p: any[]) => Output
+): void {
+    for (const c of cases) {
+        it(c.case, function () {
+            assert.strictEqual(c.params ? f(c.input, ...c.params) : f(c.input), c.output)
+        })
+    }
+}
+
 describe('sanitizeFilename', function () {
-    const cases: { input: string; output: string; case: string; replaceString?: string }[] = [
+    const cases = [
         { input: 'foo🤷', output: 'foo_', case: 'removes emojis' },
         { input: 'foo/zub', output: 'foo_zub', case: 'replaces slash with underscore' },
         { input: 'foo zub', output: 'foo_zub', case: 'replaces space with underscore' },
-        { input: 'foo:bar', output: 'fooXbar', replaceString: 'X', case: 'replaces dot with replaceString' },
+        { input: 'foo:bar', output: 'fooXbar', params: ['X'], case: 'replaces dot with replaceString' },
         { input: 'foo🤷bar/zu b.txt', output: 'foo_bar_zu_b.txt', case: 'docstring example' },
         { input: 'foo.txt', output: 'foo.txt', case: 'keeps dot' },
         { input: 'züb', output: 'züb', case: 'keeps special chars' },
     ]
-    cases.forEach((testCase) => {
-        it(testCase.case, function () {
-            assert.strictEqual(sanitizeFilename(testCase.input, testCase.replaceString), testCase.output)
-        })
-    })
+    generateTestCases(cases, sanitizeFilename)
 })
 
 describe('undefinedIfEmpty', function () {
@@ -157,9 +173,37 @@ describe('undefinedIfEmpty', function () {
         { input: ' foo ', output: ' foo ', case: 'return original str without trim' },
     ]
 
-    cases.forEach((testCases) => {
-        it(testCases.case, function () {
-            assert.strictEqual(undefinedIfEmpty(testCases.input), testCases.output)
-        })
-    })
+    generateTestCases(cases, undefinedIfEmpty)
+})
+
+describe('formatStringWithIndent', function () {
+    const cases = [
+        { input: 'foo', output: 'foo', params: ['  '], case: 'return str if input is not multiline' },
+        {
+            input: 'foo\nbar',
+            output: 'foo\n   bar',
+            params: ['   '],
+            case: 'return str with indent if input is multiline',
+        },
+        {
+            input: 'foo\n\nbar',
+            output: 'foo\n  \n  bar',
+            params: ['  '],
+            case: 'return str with indent if input is multiline with empty line',
+        },
+        {
+            input: 'foo\nbar\nfoo\nbar\n',
+            output: 'foo\n  bar\n  foo\n  bar\n  ',
+            params: ['  '],
+            case: 'return str with indent if input is multiline with empty line at the end',
+        },
+        {
+            input: 'foo\nbar\nfoo\nbar\n',
+            output: 'foo\nbar\nfoo\nbar\n',
+            params: [''],
+            case: 'returns original string with empty indent',
+        },
+    ]
+
+    generateTestCases(cases, formatTextWithIndent)
 })