add basic code action test

Author: zardoy

typescript/src/types.ts

@@ -11,4 +11,4 @@ export type LanguageServiceMethodWithConfig<T extends keyof ConditionalPick<ts.L
     ...args: Parameters<ts.LanguageService[T]>
 ) => ReturnType<ts.LanguageService[T]>
 
-export type PluginCreateArg = Pick<ts.server.PluginCreateInfo, 'languageService' | 'languageServiceHost' | 'config'>
+export type PluginCreateArg = Pick<ts.server.PluginCreateInfo, 'languageService' | 'languageServiceHost' | 'config' | 'serverHost'>

typescript/test/codeActions.spec.ts

@@ -0,0 +1,19 @@
+import { fourslashLikeTester } from './testing'
+
+test('Split Declaration and Initialization', () => {
+    const { codeAction } = fourslashLikeTester(
+        /* ts */ `
+            /*t*/const/*t*/ a = 1
+        `,
+        undefined,
+        { dedent: true },
+    )
+
+    codeAction(0, {
+        refactorName: 'Split Declaration and Initialization',
+        newContent: /* ts */ `
+            let a: number
+            a = 1
+        `,
+    })
+})

typescript/test/completions.spec.ts

@@ -738,18 +738,18 @@ test('Object Literal Completions', () => {
       [
         "a",
         "b",
-        "b: \\"$1\\",$0",
+        "b: \\"$1\\",",
       ]
     `)
     // I guess vitest hangs forever here
     expect(pos3.map(x => x.insertText)).toMatchInlineSnapshot(`
       [
         "bar",
-        "bar: \${1|true,false|},$0",
+        "bar: \${1|true,false|},",
         "bar2",
         "bar2: false,",
         "foo",
-        "foo: \${1|true,false|},$0",
+        "foo: \${1|true,false|},",
       ]
     `)
     expect(pos4.filter(x => x.insertText?.includes(': '))).toEqual([])

typescript/test/testing.ts

@@ -1,6 +1,8 @@
 import _ from 'lodash'
 import { getCompletionsAtPosition as getCompletionsAtPositionRaw } from '../src/completionsAtPosition'
 import { Configuration } from '../src/types'
+import codeActionsDecorateProxy from '../src/codeActions/decorateProxy'
+import { dedentString } from '../src/utils'
 import { defaultConfigFunc, entrypoint, sharedLanguageService, settingsOverride, currentTestingContext } from './shared'
 
 interface CompletionPartMatcher {
@@ -25,6 +27,10 @@ interface CodeActionMatcher {
 
 const { languageService, languageServiceHost, updateProject, getCurrentFile } = sharedLanguageService
 
+const fakeProxy = {} as Pick<typeof languageService, 'getApplicableRefactors' | 'getEditsForRefactor'>
+
+codeActionsDecorateProxy(fakeProxy as typeof languageService, languageService, languageServiceHost, defaultConfigFunc)
+
 export const getCompletionsAtPosition = (pos: number, { fileName = entrypoint, shouldHave }: { fileName?: string; shouldHave?: boolean } = {}) => {
     if (pos === undefined) throw new Error('getCompletionsAtPosition: pos is undefined')
     const result = getCompletionsAtPositionRaw(
@@ -70,7 +76,8 @@ export const overrideSettings = (newOverrides: Partial<Configuration>) => {
     })
 }
 
-export const fourslashLikeTester = (contents: string, fileName = entrypoint) => {
+export const fourslashLikeTester = (contents: string, fileName = entrypoint, { dedent = false }: { dedent? } = {}) => {
+    if (dedent) contents = dedentString(contents)
     const [positive, _negative, numberedPositions] = fileContentsSpecialPositions(contents, fileName)
 
     const ranges = positive.reduce<number[][]>(
@@ -141,17 +148,25 @@ export const fourslashLikeTester = (contents: string, fileName = entrypoint) =>
                 if (!ranges[mark]) throw new Error(`No range with index ${mark} found, highest index is ${ranges.length - 1}`)
                 const start = ranges[mark]![0]!
                 const end = ranges[mark]![0]!
-                const appliableRefactors = languageService.getApplicableRefactors(fileName, { pos: start, end }, {}, 'invoked')
-                const appliableNames = appliableRefactors.map(appliableRefactor => appliableRefactor.actions.map(action => action.description))
+                const appliableRefactors = fakeProxy.getApplicableRefactors(fileName, { pos: start, end }, {}, 'invoked')
+                const appliableNames = appliableRefactors.flatMap(appliableRefactor => appliableRefactor.actions.map(action => action.description))
                 const { refactorName, newContent } = matcher
                 if (newContent) {
                     expect(appliableNames, `at marker ${mark}`).toContain(refactorName)
                     const actionsGroup = appliableRefactors.find(appliableRefactor =>
                         appliableRefactor.actions.find(action => action.description === refactorName),
                     )!
                     const action = actionsGroup.actions.find(action => action.description === refactorName)!
-                    const { edits } = languageService.getEditsForRefactor(fileName, {}, { pos: start, end }, actionsGroup.name, action.name, {})!
-                    const a = tsFull.textChanges.applyChanges(getCurrentFile(), edits[0]!.textChanges)
+                    const { edits } = fakeProxy.getEditsForRefactor(
+                        fileName,
+                        ts.getDefaultFormatCodeSettings(),
+                        { pos: start, end },
+                        actionsGroup.name,
+                        action.name,
+                        {},
+                    )!
+                    const newContentsActual = tsFull.textChanges.applyChanges(getCurrentFile(), edits[0]!.textChanges)
+                    expect(dedentString(newContent), `at marker ${mark}`).toEqual(newContentsActual)
                 } else {
                     expect(appliableNames, `at marker ${mark}`).not.toContain(refactorName)
                 }