test: extract pure functions to better testing (#71)

* test: extract pure functions to better testing

* cleanup

* update

Author: 9romise

src/providers/diagnostics/rules/engine-mismatch.ts

@@ -7,14 +7,14 @@ import intersects from 'semver/ranges/intersects'
 import subset from 'semver/ranges/subset'
 import { DiagnosticSeverity, Uri } from 'vscode'
 
-interface EngineMismatch {
+export interface EngineMismatch {
   engine: string
   packageRange: string
   dependencyRange: string
   hasIntersection: boolean
 }
 
-function resolveEngineMismatches(
+export function resolveEngineMismatches(
   packageEngines: Engines,
   dependencyEngines: Engines,
 ) {

src/providers/diagnostics/rules/upgrade.ts

@@ -1,4 +1,5 @@
 import type { ValidNode } from '#types/extractor'
+import type { ParsedVersion } from '#utils/version'
 import type { DiagnosticRule, NodeDiagnosticInfo } from '..'
 import { config } from '#state'
 import { checkIgnored } from '#utils/ignore'
@@ -9,48 +10,78 @@ import lte from 'semver/functions/lte'
 import prerelease from 'semver/functions/prerelease'
 import { DiagnosticSeverity, Uri } from 'vscode'
 
-function createUpgradeDiagnostic(node: ValidNode, name: string, targetVersion: string): NodeDiagnosticInfo {
-  return {
-    node,
-    severity: DiagnosticSeverity.Hint,
-    message: `"${name}" can be upgraded to ${targetVersion}.`,
-    code: {
-      value: 'upgrade',
-      target: Uri.parse(npmxPackageUrl(name, targetVersion)),
-    },
-  }
+export interface ResolveUpgradeOptions {
+  name: string
+  version: string
+  parsed: ParsedVersion
+  exactVersion: string
+  distTags: Record<string, string>
+  ignoreList: string[]
 }
 
-export const checkUpgrade: DiagnosticRule = ({ dep, name, pkg, parsed, exactVersion }) => {
-  if (!parsed || !exactVersion)
-    return
+export interface UpgradeResult {
+  name: string
+  targetVersion: string
+}
+
+export function resolveUpgrade(options: ResolveUpgradeOptions): UpgradeResult | undefined {
+  const { name, version, parsed, exactVersion, distTags, ignoreList } = options
 
-  if (Object.hasOwn(pkg.distTags, dep.version))
+  if (Object.hasOwn(distTags, version))
     return
 
-  const { latest } = pkg.distTags
+  const { latest } = distTags
   if (gt(latest, exactVersion)) {
     const targetVersion = formatUpgradeVersion(parsed, latest)
-    if (checkIgnored({ ignoreList: config.ignore.upgrade, name, version: targetVersion }))
+    if (checkIgnored({ ignoreList, name, version: targetVersion }))
       return
-    return createUpgradeDiagnostic(dep.versionNode, name, targetVersion)
+    return { name, targetVersion }
   }
 
   const currentPreId = prerelease(exactVersion)?.[0]
   if (currentPreId == null)
     return
 
-  for (const [tag, tagVersion] of Object.entries(pkg.distTags)) {
+  for (const [tag, tagVersion] of Object.entries(distTags)) {
     if (tag === 'latest')
       continue
     if (prerelease(tagVersion)?.[0] !== currentPreId)
       continue
     if (lte(tagVersion, exactVersion))
       continue
     const targetVersion = formatUpgradeVersion(parsed, tagVersion)
-    if (checkIgnored({ ignoreList: config.ignore.upgrade, name, version: targetVersion }))
+    if (checkIgnored({ ignoreList, name, version: targetVersion }))
       continue
 
-    return createUpgradeDiagnostic(dep.versionNode, name, targetVersion)
+    return { name, targetVersion }
+  }
+}
+
+function createUpgradeDiagnostic(node: ValidNode, name: string, targetVersion: string): NodeDiagnosticInfo {
+  return {
+    node,
+    severity: DiagnosticSeverity.Hint,
+    message: `"${name}" can be upgraded to ${targetVersion}.`,
+    code: {
+      value: 'upgrade',
+      target: Uri.parse(npmxPackageUrl(name, targetVersion)),
+    },
   }
 }
+
+export const checkUpgrade: DiagnosticRule = ({ dep, name, pkg, parsed, exactVersion }) => {
+  if (!parsed || !exactVersion)
+    return
+
+  const result = resolveUpgrade({
+    name,
+    version: dep.version,
+    parsed,
+    exactVersion,
+    distTags: pkg.distTags,
+    ignoreList: config.ignore.upgrade,
+  })
+
+  if (result)
+    return createUpgradeDiagnostic(dep.versionNode, result.name, result.targetVersion)
+}

tests/diagnostics/deprecation.test.ts

@@ -21,27 +21,24 @@ function createDeprecationContext(version: string) {
 
 describe('checkDeprecation', () => {
   it('should flag deprecated version', async () => {
-    const ctx = createDeprecationContext('1.0.0')
-    const result = await checkDeprecation(ctx)
+    const result = await checkDeprecation(createDeprecationContext('1.0.0'))
 
-    expect(result).toBeDefined()
+    expect(result).toMatchObject({
+      code: { value: 'deprecation' },
+    })
     expect(result!.message).toMatchInlineSnapshot('""lodash@1.0.0" has been deprecated: old notice"')
-    expect(result!.code).toMatchObject({ value: 'deprecation' })
   })
 
   it('resolve range to the highest matching deprecated version', async () => {
-    const ctx = createDeprecationContext('^1.0.0')
-    const result = await checkDeprecation(ctx)
+    const result = await checkDeprecation(createDeprecationContext('^1.0.0'))
 
-    expect(result).toBeDefined()
+    expect(result).toMatchObject({
+      code: { value: 'deprecation' },
+    })
     expect(result!.message).toMatchInlineSnapshot('""lodash@1.2.0" has been deprecated: new notice"')
-    expect(result!.code).toMatchObject({ value: 'deprecation' })
   })
 
   it('should not flag non-deprecated version', async () => {
-    const ctx = createDeprecationContext('^2.0.0')
-    const result = await checkDeprecation(ctx)
-
-    expect(result).toBeUndefined()
+    expect(await checkDeprecation(createDeprecationContext('^2.0.0'))).toBeUndefined()
   })
 })

tests/diagnostics/dist-tag.test.ts

@@ -4,17 +4,16 @@ import { createContext } from './context'
 
 describe('checkDistTag', () => {
   it('should flag when version matches a dist tag', async () => {
-    const ctx = createContext({ name: 'lodash', version: 'latest', distTags: { latest: '2.0.0' } })
-    const result = await checkDistTag(ctx)
-
-    expect(result).toBeDefined()
-    expect(result!.code).toMatchObject({ value: 'dist-tag' })
+    expect(await checkDistTag(
+      createContext({ name: 'lodash', version: 'latest', distTags: { latest: '2.0.0' } }),
+    )).toMatchObject({
+      code: { value: 'dist-tag' },
+    })
   })
 
   it('should not flag when version does not match any dist tag', async () => {
-    const ctx = createContext({ name: 'lodash', version: 'next', distTags: { latest: '2.0.0' } })
-    const result = await checkDistTag(ctx)
-
-    expect(result).toBeUndefined()
+    expect(await checkDistTag(
+      createContext({ name: 'lodash', version: 'next', distTags: { latest: '2.0.0' } }),
+    )).toBeUndefined()
   })
 })

tests/diagnostics/engine-mismatch.test.ts

@@ -1,89 +1,101 @@
-import type { Engines } from 'fast-npm-meta'
 import { describe, expect, it } from 'vitest'
-import { checkEngineMismatch } from '../../src/providers/diagnostics/rules/engine-mismatch'
+import { checkEngineMismatch, resolveEngineMismatches } from '../../src/providers/diagnostics/rules/engine-mismatch'
 import { createContext } from './context'
 
-function createEngineMismatchContext(
-  engines: Engines | undefined,
-  dependencyEngines: Engines | undefined,
-) {
-  return createContext({
-    name: 'foo',
-    version: '^1.0.0',
-    distTags: { latest: '1.0.0' },
-    versionsMeta: {
-      '1.0.0': dependencyEngines ? { engines: dependencyEngines } : {},
-    },
-    engines,
-  })
-}
-
-describe('checkEngineMismatch', () => {
-  it('should flag when engine ranges do not overlap', async () => {
-    const ctx = createEngineMismatchContext(
+describe('resolveEngineMismatches', () => {
+  it('should flag when engine ranges do not overlap', () => {
+    expect(resolveEngineMismatches(
       { node: '^18.0.0' },
       { node: '>=20' },
-    )
-    const result = await checkEngineMismatch(ctx)
-
-    expect(result).toBeDefined()
-    expect(result!.code).toMatchObject({ value: 'engine-mismatch' })
-    expect(result!.message).toContain('requires ">=20", but package supports "^18.0.0"')
+    )).toMatchObject([
+      {
+        engine: 'node',
+        packageRange: '^18.0.0',
+        dependencyRange: '>=20',
+        hasIntersection: false,
+      },
+    ])
   })
 
-  it('should flag when engine ranges overlap but are not fully compatible', async () => {
-    const ctx = createEngineMismatchContext(
+  it('should flag when engine ranges overlap but are not fully compatible', () => {
+    expect(resolveEngineMismatches(
       { node: '>=20', npm: '>=8 <11' },
       { node: '>=18', npm: '>=10 <12' },
-    )
-    const result = await checkEngineMismatch(ctx)
-
-    expect(result).toBeDefined()
-    expect(result!.message).toContain('npm')
-    expect(result!.message).toContain('partial overlap')
+    )).toMatchObject([{
+      engine: 'npm',
+      hasIntersection: true,
+    }])
   })
 
-  it('should include multiple engine mismatches in one diagnostic', async () => {
-    const ctx = createEngineMismatchContext(
+  it('should include multiple engine mismatches', () => {
+    expect(resolveEngineMismatches(
       { node: '^18.0.0', npm: '^9.0.0' },
       { node: '>=20', npm: '>=10' },
-    )
-    const result = await checkEngineMismatch(ctx)
-
-    expect(result).toBeDefined()
-    expect(result!.message).toContain('node')
-    expect(result!.message).toContain('npm')
+    )).toMatchObject([
+      { engine: 'node' },
+      { engine: 'npm' },
+    ])
   })
 
-  it('should not flag when package ranges are compatible', async () => {
-    const ctx = createEngineMismatchContext(
+  it('should not flag when package ranges are compatible', () => {
+    expect(resolveEngineMismatches(
       { node: '>=20', npm: '>=10' },
       { node: '>=18', npm: '>=10' },
-    )
-
-    expect(await checkEngineMismatch(ctx)).toBeUndefined()
+    )).toEqual([])
   })
 
-  it('should not flag when package does not declare the dependency engine', async () => {
-    const ctx = createEngineMismatchContext(
+  it('should not flag when package does not declare the dependency engine', () => {
+    expect(resolveEngineMismatches(
       { node: '>=20' },
       { npm: '>=10' },
-    )
+    )).toEqual([])
+  })
 
-    expect(await checkEngineMismatch(ctx)).toBeUndefined()
+  it('should skip engines with non-standard semver values', () => {
+    expect(resolveEngineMismatches(
+      { node: '>=18' },
+      { node: 'lts' },
+    )).toEqual([])
   })
+})
 
-  it('should not flag when either engines is missing', async () => {
-    expect(await checkEngineMismatch(createEngineMismatchContext(undefined, { node: '>=18' }))).toBeUndefined()
-    expect(await checkEngineMismatch(createEngineMismatchContext({ node: '>=18' }, undefined))).toBeUndefined()
+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 skip engines with non-standard semver values', async () => {
-    const ctx = createEngineMismatchContext(
-      { node: '>=18' },
-      { node: 'lts' },
-    )
+  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(ctx)).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/replacement.test.ts

@@ -3,26 +3,17 @@ import { checkReplacement } from '../../src/providers/diagnostics/rules/replacem
 import { createContext } from './context'
 
 function createReplacementContext(name: string) {
-  return createContext({
-    name,
-    version: '^1.0.0',
-    distTags: { latest: '1.0.0' },
-    versionsMeta: { '1.0.0': {} },
-  })
+  return createContext({ name, version: '^1.0.0' })
 }
 
 describe('checkReplacement', () => {
   it('should flag when replacement found', async () => {
-    const result = await checkReplacement(createReplacementContext('left-pad'))
-
-    expect(result).toBeDefined()
-    expect(result!.message).toBeDefined()
-    expect(result!.code).toMatchObject({ value: 'replacement' })
+    expect(await checkReplacement(createReplacementContext('left-pad'))).toMatchObject({
+      code: { value: 'replacement' },
+    })
   })
 
   it('should not flag when no replacement found', async () => {
-    const result = await checkReplacement(createReplacementContext('vitest'))
-
-    expect(result).toBeUndefined()
+    expect(await checkReplacement(createReplacementContext('vitest'))).toBeUndefined()
   })
 })