test: fix merge

Author: 9romise

src/providers/diagnostics/rules/upgrade.ts

@@ -11,24 +11,23 @@ import lte from 'semver/functions/lte'
 import prerelease from 'semver/functions/prerelease'
 import { DiagnosticSeverity, Uri } from 'vscode'
 
-export function resolveUpgrade(dep: ResolvedDependencyInfo, pkg: PackageInfo, exactVersion: string) {
+export function resolveUpgrade(dep: ResolvedDependencyInfo, pkg: PackageInfo, resolvedVersion: string, ignoreList = config.ignore.upgrade) {
   const { distTags } = pkg
   if (Object.hasOwn(distTags, dep.resolvedSpec))
     return
 
-  const ignoreList = config.ignore.upgrade
   const { latest } = distTags
   const { resolvedName } = dep
 
-  if (gt(latest, exactVersion)) {
+  if (gt(latest, resolvedVersion)) {
     const targetVersion = formatUpgradeVersion(dep, latest)
     if (checkIgnored({ ignoreList, name: resolvedName, version: targetVersion }))
       return
 
     return targetVersion
   }
 
-  const currentPreId = prerelease(exactVersion)?.[0]
+  const currentPreId = prerelease(resolvedVersion)?.[0]
   if (currentPreId == null)
     return
 
@@ -37,7 +36,7 @@ export function resolveUpgrade(dep: ResolvedDependencyInfo, pkg: PackageInfo, ex
       continue
     if (prerelease(tagVersion)?.[0] !== currentPreId)
       continue
-    if (lte(tagVersion, exactVersion))
+    if (lte(tagVersion, resolvedVersion))
       continue
     const targetVersion = formatUpgradeVersion(dep, tagVersion)
     if (checkIgnored({ ignoreList, name: resolvedName, version: targetVersion }))
@@ -60,11 +59,11 @@ function createUpgradeDiagnostic(range: OffsetRange, name: string, targetVersion
 }
 
 export const checkUpgrade: DiagnosticRule = async ({ dep, pkg }) => {
-  const exactVersion = await dep.resolvedVersion()
-  if (!exactVersion)
+  const resolvedVersion = await dep.resolvedVersion()
+  if (!resolvedVersion)
     return
 
-  const result = resolveUpgrade(dep, pkg, exactVersion)
+  const result = resolveUpgrade(dep, pkg, resolvedVersion)
   if (!result)
     return
 

tests/diagnostics/context.ts

@@ -19,7 +19,7 @@ interface CreateContextOptions {
 export function createContext(options: CreateContextOptions): DiagnosticContext {
   const { name, version, distTags = {}, versionsMeta = {} } = options
   const { protocol, resolvedName, resolvedSpec, resolvedProtocol } = resolveDependencySpec(name, version)
-  const pkg = { distTags, versionsMeta, versionToTag: new Map() } as PackageInfo
+  const pkg = { distTags, versionsMeta } as PackageInfo
 
   const dep: DiagnosticContext['dep'] = {
     category: 'dependencies',

tests/diagnostics/engine-mismatch.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { checkEngineMismatch, resolveEngineMismatches } from '../../src/providers/diagnostics/rules/engine-mismatch'
-import { createContext } from './context'
+import { resolveEngineMismatches } from '../../src/providers/diagnostics/rules/engine-mismatch'
 
 describe('resolveEngineMismatches', () => {
   it('should flag when engine ranges do not overlap', () => {
@@ -58,44 +57,3 @@ describe('resolveEngineMismatches', () => {
     )).toEqual([])
   })
 })
-
-describe('checkEngineMismatch', () => {
-  it('should format a diagnostic when mismatches exist', async () => {
-    const result = await checkEngineMismatch(createContext({
-      name: 'foo',
-      version: '^1.0.0',
-      distTags: { latest: '1.0.0' },
-      versionsMeta: {
-        '1.0.0': {
-          engines: { node: '>=20' },
-        },
-      },
-      engines: { node: '^18.0.0' },
-    }))
-
-    expect(result).toBeDefined()
-    expect(result!.code).toMatchObject({ value: 'engine-mismatch' })
-    expect(result!.message).toContain('requires ">=20", but package supports "^18.0.0"')
-  })
-
-  it('should not flag when either engines is missing', async () => {
-    expect(await checkEngineMismatch(createContext({
-      name: 'foo',
-      version: '^1.0.0',
-      distTags: { latest: '1.0.0' },
-      versionsMeta: {
-        '1.0.0': { engines: { node: '>=18' } },
-      },
-    }))).toBeUndefined()
-
-    expect(await checkEngineMismatch(createContext({
-      name: 'foo',
-      version: '^1.0.0',
-      distTags: { latest: '1.0.0' },
-      versionsMeta: {
-        '1.0.0': {},
-      },
-      engines: { node: '>=18' },
-    }))).toBeUndefined()
-  })
-})

tests/diagnostics/upgrade.test.ts

@@ -1,9 +1,8 @@
+import type { ResolvedDependencyInfo } from '#types/context'
 import type { PackageInfo } from '#utils/api/package'
-import type { ResolveUpgradeOptions } from '../../src/providers/diagnostics/rules/upgrade'
-import { resolveExactVersion } from '#utils/package'
-import { isSupportedProtocol, parseVersion } from '#utils/version'
 import { describe, expect, it } from 'vitest'
 import { resolveUpgrade } from '../../src/providers/diagnostics/rules/upgrade'
+import { createContext } from './context'
 
 const distTags: Record<string, string> = {
   latest: '2.7.0',
@@ -17,53 +16,38 @@ const versionsMeta: Record<string, object> = {
   '3.0.0-alpha.5': {},
 }
 
-function createOptions(version: string, ignoreList: string[] = []): ResolveUpgradeOptions | undefined {
-  const parsed = parseVersion(version)
-  if (!parsed)
-    return
-  const exactVersion = isSupportedProtocol(parsed.protocol)
-    ? resolveExactVersion({ distTags, versionsMeta, versionToTag: new Map() } as PackageInfo, parsed.version)
-    : null
-  if (!exactVersion)
-    return
-  return { name: 'vite', version, parsed, exactVersion, distTags, ignoreList }
+async function createOptions(version: string): Promise<[ResolvedDependencyInfo, PackageInfo, string]> {
+  const ctx = createContext({ name: 'vite', version, distTags, versionsMeta })
+  return [ctx.dep, ctx.pkg, (await ctx.dep.resolvedVersion())!]
 }
 
 describe('resolveUpgrade', () => {
-  it('should flag when latest is greater than current version', () => {
-    expect(resolveUpgrade(createOptions('^1.0.0')!)).toMatchObject({
-      name: 'vite',
-      targetVersion: '^2.7.0',
-    })
+  it('should flag when latest is greater than current version', async () => {
+    expect(resolveUpgrade(...await createOptions('^1.0.0'))).toBe('^2.7.0')
   })
 
   it.each([
     '^2.7.0',
     'latest',
     'npm:latest',
     '3.0.0-alpha.5',
-  ])('should not flag for "%s"', (version) => {
-    const options = createOptions(version)
+  ])('should not flag for "%s"', async (version) => {
+    const options = await createOptions(version)
     if (!options) {
-      expect(options).toBeUndefined()
       return
     }
-    expect(resolveUpgrade(options)).toBeUndefined()
+    expect(resolveUpgrade(...options)).toBeUndefined()
   })
 
-  it('should flag prerelease upgrade within same pre-id', () => {
-    expect(resolveUpgrade(createOptions('3.0.0-alpha.1')!)).toMatchObject({
-      targetVersion: '3.0.0-alpha.5',
-    })
+  it('should flag prerelease upgrade within same pre-id', async () => {
+    expect(resolveUpgrade(...await createOptions('3.0.0-alpha.1'))).toBe('3.0.0-alpha.5')
   })
 
-  it('should not flag when target upgrade version is ignored', () => {
-    expect(resolveUpgrade(createOptions('^1.0.0', ['vite@^2.7.0'])!)).toBeUndefined()
+  it('should not flag when target upgrade version is ignored', async () => {
+    expect(resolveUpgrade(...await createOptions('^1.0.0'), ['vite@^2.7.0'])).toBeUndefined()
   })
 
-  it('should preserve protocol prefix in targetVersion', () => {
-    expect(resolveUpgrade(createOptions('npm:^1.0.0')!)).toMatchObject({
-      targetVersion: 'npm:^2.7.0',
-    })
+  it('should preserve protocol prefix in targetVersion', async () => {
+    expect(resolveUpgrade(...await createOptions('npm:^1.0.0'))).toBe('npm:^2.7.0')
   })
 })