test(manifest): cover the .NET facts producer

Unit tests for .NET detection, discovery order and coverage, the no-SDK
skip, assembly, the per-framework sidecar and NuGet failure
classification, plus `run-compat.sh dotnet`: stub-package fixtures run
through the built CLI per SDK, each project's tree compared with
`dotnet list package --include-transitive`, with fixture assertions for
the dev rule, coverage, solution configurations, twins, design-time build
inputs and failures.

Author: jfblaa

src/commands/fix/coana-fix-dynamic-sbom-inference.test.mts

@@ -124,6 +124,7 @@ describe('socket fix --dynamic-sbom-inference', () => {
   const uploadManifestFiles = vi.fn()
   const generated = {
     paths: [FACTS],
+    sidecar: undefined,
     sidecarFile: '/tmp/socket-fix-facts/sidecar.json',
     remove: vi.fn(),
     restore: vi.fn(),

src/commands/manifest/cmd-manifest-dotnet.test.mts

@@ -0,0 +1,85 @@
+import { describe, expect } from 'vitest'
+
+import constants, {
+  FLAG_CONFIG,
+  FLAG_DRY_RUN,
+  FLAG_HELP,
+} from '../../../src/constants.mts'
+import { cmdit, spawnSocketCli } from '../../../test/utils.mts'
+
+describe('socket manifest dotnet', async () => {
+  const { binCliPath } = constants
+
+  cmdit(
+    ['manifest', 'dotnet', FLAG_HELP, FLAG_CONFIG, '{}'],
+    `should support ${FLAG_HELP}`,
+    async cmd => {
+      const { code, stderr, stdout } = await spawnSocketCli(binCliPath, cmd)
+      expect(stdout).toMatchInlineSnapshot(`
+        "[beta] Generate Socket facts files from .NET solutions and projects
+
+          Usage
+            $ socket manifest dotnet [options] [CWD=.|FILE]
+
+          Options
+            --bin               Location of the dotnet binary to use, default: dotnet on PATH
+            --dotnet-opts       Additional options to pass on to \`dotnet restore\`, e.g. \`-p:Configuration=Release --configfile nuget.config\`. MSBuild properties among them also apply to project evaluation
+            --exclude-configs   Comma-separated glob patterns; target frameworks matching any pattern are skipped (applied after --include-configs)
+            --exclude-paths     List of glob patterns to exclude from manifest/facts generation. Patterns are anchored micromatch globs matched relative to CWD (\`--cwd\` if set): \`tests\` matches only \`<cwd>/tests\`; use \`**/tests\` to match at any depth. Negation patterns (\`!path\`) are not supported. Accepts a comma-separated value or multiple flags. An excluded JVM build module is not analysed as a project of its own, but where a project that is not excluded depends on it, its code is analysed as part of that project.
+            --ignore-unresolved  Warn on unresolved dependencies instead of failing the run (unresolved deps are not emitted to the facts file)
+            --include-configs   Comma-separated glob patterns matched against target frameworks (case-sensitive; \`*\`, \`?\`, and \`[...]\` wildcards). Only target frameworks matching at least one pattern are read, e.g. \`net8.0\`. A runtime-specific target (\`net8.0/win-x64\`) also matches its framework. Default: every target framework
+            --verbose           Print debug messages
+
+          Emits a \`<file>.socket.facts.json\` per solution or project describing its
+          resolved NuGet dependency graph. Given a directory, it builds every
+          solution (.sln, .slnx) and project (.csproj, .fsproj, .vbproj) at its top
+          level, solutions first, skipping projects a solution already covers; given
+          a file, just that one (a .slnf solution filter too).
+
+          Dependencies come from your own \`dotnet restore\` (same SDK, global.json,
+          nuget.config and credential providers), so a build that restores for you
+          restores here. PackageReference projects (central package management and
+          lock files included) and packages.config projects are supported. An
+          unresolved dependency is a fatal error unless --ignore-unresolved.
+
+          Support is beta. Please report issues or give us feedback on what's missing.
+
+          Examples
+
+            $ socket manifest dotnet .
+            $ socket manifest dotnet ./App.sln
+            $ socket manifest dotnet --dotnet-opts="-p:Configuration=Release" ."
+      `)
+      expect(`\n   ${stderr}`).toMatchInlineSnapshot(`
+        "
+           _____         _       _        /---------------
+          |   __|___ ___| |_ ___| |_      | CLI: <redacted>
+          |__   | * |  _| '_| -_|  _|     | token: <redacted>, org: <redacted>
+          |_____|___|___|_,_|___|_|.dev   | Command: \`socket manifest dotnet\`, cwd: <redacted>"
+      `)
+
+      expect(code, 'explicit help should exit with code 0').toBe(0)
+      expect(stderr, 'banner includes base command').toContain(
+        '`socket manifest dotnet`',
+      )
+    },
+  )
+
+  cmdit(
+    ['manifest', 'dotnet', FLAG_DRY_RUN, FLAG_CONFIG, '{}'],
+    'should require args with just dry-run',
+    async cmd => {
+      const { code, stderr, stdout } = await spawnSocketCli(binCliPath, cmd)
+      expect(stdout).toMatchInlineSnapshot(`"[DryRun]: Bailing now"`)
+      expect(`\n   ${stderr}`).toMatchInlineSnapshot(`
+        "
+           _____         _       _        /---------------
+          |   __|___ ___| |_ ___| |_      | CLI: <redacted>
+          |__   | * |  _| '_| -_|  _|     | token: <redacted>, org: <redacted>
+          |_____|___|___|_,_|___|_|.dev   | Command: \`socket manifest dotnet\`, cwd: <redacted>"
+      `)
+
+      expect(code, 'dry-run should exit with code 0 if input ok').toBe(0)
+    },
+  )
+})

src/commands/manifest/detect-manifest-actions.test.mts

@@ -1,10 +1,13 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
-import { detectManifestActions } from './detect-manifest-actions.mts'
+import {
+  detectManifestActions,
+  findDotnetEntries,
+} from './detect-manifest-actions.mts'
 
 import type { SocketJson } from '../../utils/socket-json.mts'
 
@@ -193,3 +196,60 @@ describe('detectManifestActions — conda detector', () => {
     expect(result.count).toBe(0)
   })
 })
+
+describe('detectManifestActions — dotnet detector', () => {
+  let cwd: string
+
+  beforeEach(() => {
+    cwd = mkTmp()
+  })
+
+  afterEach(() => {
+    rmSync(cwd, { recursive: true, force: true })
+  })
+
+  it.each([
+    'App.sln',
+    'App.slnx',
+    'App.csproj',
+    'App.fsproj',
+    'App.vbproj',
+    'APP.SLN',
+  ])('detects %s', async name => {
+    touch(cwd, name)
+    expect((await detectManifestActions(null, cwd)).dotnet).toBe(true)
+  })
+
+  it('ignores a solution filter, other files and directories named like projects', async () => {
+    touch(cwd, 'App.slnf')
+    touch(cwd, 'App.sqlproj')
+    mkdirSync(path.join(cwd, 'Lib.csproj'))
+    expect((await detectManifestActions(null, cwd)).dotnet).toBe(false)
+  })
+
+  it('skips dotnet when defaults.manifest.dotnet.disabled is true', async () => {
+    touch(cwd, 'App.sln')
+    const sockJson = {
+      defaults: { manifest: { dotnet: { disabled: true } } },
+    } as unknown as SocketJson
+    expect((await detectManifestActions(sockJson, cwd)).dotnet).toBe(false)
+  })
+
+  it('lists solutions before projects, each sorted by name', () => {
+    for (const name of [
+      'b.csproj',
+      'A.vbproj',
+      'Z.sln',
+      'M.slnx',
+      'notes.txt',
+    ]) {
+      touch(cwd, name)
+    }
+    expect(findDotnetEntries(cwd)).toEqual([
+      'M.slnx',
+      'Z.sln',
+      'A.vbproj',
+      'b.csproj',
+    ])
+  })
+})

src/commands/manifest/discover-manifest-roots.test.mts

@@ -8,6 +8,7 @@ import {
   buildRootPath,
   findBuildToolCandidates,
   isBuildRootCovered,
+  isSolutionCovered,
   sortByDepthThenPath,
 } from './discover-manifest-roots.mts'
 import { testPath } from '../../../test/utils.mts'
@@ -239,6 +240,22 @@ describe('isBuildRootCovered', () => {
     ).toBe(false)
   })
 
+  it('covers a .NET project by its project file, never a solution', () => {
+    const covered = new Set(['/repo/src/App/App.csproj'])
+    expect(
+      isBuildRootCovered(covered, 'dotnet', {
+        dir: '/repo/src/App',
+        entryFile: 'App.csproj',
+      }),
+    ).toBe(true)
+    expect(
+      isBuildRootCovered(covered, 'dotnet', {
+        dir: '/repo/src/App',
+        entryFile: 'App.sln',
+      }),
+    ).toBe(false)
+  })
+
   it('covers a root without an entry file through a marker file', () => {
     expect(
       isBuildRootCovered(new Set(['/repo/lib/settings.gradle.kts']), 'gradle', {
@@ -274,4 +291,132 @@ describe('sortByDepthThenPath', () => {
       { dir: '/repo/b/nested' },
     ])
   })
+
+  it('puts the solutions of a directory before its projects', () => {
+    expect(
+      sortByDepthThenPath(
+        [
+          { dir: '/repo', entryFile: 'App.csproj' },
+          { dir: '/repo', entryFile: 'Zed.slnx' },
+          { dir: '/repo', entryFile: 'App.sln' },
+        ],
+        '/repo',
+      ),
+    ).toEqual([
+      { dir: '/repo', entryFile: 'App.sln' },
+      { dir: '/repo', entryFile: 'Zed.slnx' },
+      { dir: '/repo', entryFile: 'App.csproj' },
+    ])
+  })
+})
+
+function listing(members: string[]) {
+  return async () => members
+}
+
+async function unreadable(): Promise<undefined> {
+  return undefined
+}
+
+async function failToList(): Promise<string[]> {
+  throw new Error('listed')
+}
+
+describe('isSolutionCovered', () => {
+  const root = { dir: '/repo', entryFile: 'App.slnx' }
+
+  it('covers a solution once every project it builds is covered', async () => {
+    const covered = new Set(['/repo/src/A/A.csproj', '/repo/src/B/B.csproj'])
+    expect(
+      await isSolutionCovered(
+        covered,
+        root,
+        {},
+        listing(['/repo/src/A/A.csproj', '/repo/src/B/B.csproj']),
+      ),
+    ).toBe(true)
+    expect(
+      await isSolutionCovered(
+        covered,
+        root,
+        {},
+        listing(['/repo/src/A/A.csproj', '/repo/src/C/C.csproj']),
+      ),
+    ).toBe(false)
+  })
+
+  it('takes a solution the SDK cannot read as covered by its twin in the other format', async () => {
+    const dir = await fs.mkdtemp(path.join(tmpdir(), 'entry-covered-'))
+    try {
+      await fs.writeFile(path.join(dir, 'App.sln'), '')
+      await fs.writeFile(path.join(dir, 'App.slnx'), '')
+      const covered = new Set(['/repo/src/A/A.csproj'])
+      const slnxUnreadable = async ({ entryFile }: { entryFile?: string }) =>
+        entryFile?.endsWith('.slnx') ? undefined : []
+      expect(
+        await isSolutionCovered(
+          covered,
+          { dir, entryFile: 'App.slnx' },
+          {},
+          slnxUnreadable,
+        ),
+      ).toBe(true)
+      // Also before anything is covered, e.g. when the twin built nothing.
+      expect(
+        await isSolutionCovered(
+          new Set(),
+          { dir, entryFile: 'App.slnx' },
+          {},
+          slnxUnreadable,
+        ),
+      ).toBe(true)
+      expect(
+        await isSolutionCovered(
+          covered,
+          { dir, entryFile: 'Other.slnx' },
+          {},
+          slnxUnreadable,
+        ),
+      ).toBe(false)
+    } finally {
+      await fs.rm(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('builds an unreadable solution whose twin is unreadable too, so its failure shows', async () => {
+    const dir = await fs.mkdtemp(path.join(tmpdir(), 'entry-covered-'))
+    try {
+      await fs.writeFile(path.join(dir, 'App.sln'), '')
+      await fs.writeFile(path.join(dir, 'App.slnx'), '')
+      const covered = await Promise.all(
+        ['App.sln', 'App.slnx'].map(entryFile =>
+          isSolutionCovered(new Set(), { dir, entryFile }, {}, unreadable),
+        ),
+      )
+      expect(covered).toEqual([false, false])
+    } finally {
+      await fs.rm(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('lists no members while nothing is covered and no twin exists, or for a project or a POM', async () => {
+    const list = failToList
+    expect(await isSolutionCovered(new Set(), root, {}, list)).toBe(false)
+    expect(
+      await isSolutionCovered(
+        new Set(['/x']),
+        { dir: '/repo', entryFile: 'A.csproj' },
+        {},
+        list,
+      ),
+    ).toBe(false)
+    expect(
+      await isSolutionCovered(
+        new Set(['/x']),
+        { dir: '/repo', entryFile: 'pom.xml' },
+        {},
+        list,
+      ),
+    ).toBe(false)
+  })
 })

src/commands/manifest/generate-recursive-manifests.test.mts

@@ -15,10 +15,15 @@ vi.mock('../../utils/socket-json.mts', () => ({
 vi.mock('./run-manifest-facts.mts', () => ({
   runManifestFacts: vi.fn(),
 }))
+vi.mock('./scripts/run.mts', async importOriginal => ({
+  ...(await importOriginal<typeof import('./scripts/run.mts')>()),
+  skipWithoutDotnetSdk: vi.fn(async () => false),
+}))
 
 import { buildRootPath } from './discover-manifest-roots.mts'
 import { generateRecursiveManifests } from './generate-recursive-manifests.mts'
 import { runManifestFacts } from './run-manifest-facts.mts'
+import { skipWithoutDotnetSdk } from './scripts/run.mts'
 import { testPath } from '../../../test/utils.mts'
 import {
   readOrDefaultSocketJson,
@@ -518,6 +523,33 @@ describe('generateRecursiveManifests', () => {
     })
   })
 
+  it('skips .NET builds, without failing, where no .NET SDK runs', async () => {
+    const dir = await fs.mkdtemp(path.join(tmpdir(), 'dsi-no-sdk-'))
+    try {
+      await fs.writeFile(path.join(dir, 'pom.xml'), '<project/>')
+      await fs.mkdir(path.join(dir, 'samples'))
+      await fs.writeFile(path.join(dir, 'samples', 'Stray.csproj'), '')
+      vi.mocked(skipWithoutDotnetSdk).mockResolvedValueOnce(true)
+      vi.mocked(runManifestFacts).mockImplementation(async ({ cwd }) => ({
+        factsPath: path.join(cwd, 'pom.xml.socket.facts.json'),
+        projects: [],
+      }))
+      const outcomes = await generateRecursiveManifests({
+        cwd: dir,
+        verbose: false,
+      })
+
+      expect(
+        outcomes.map(o => `${o.ecosystem}:${o.entryFile}:${o.status}`).sort(),
+      ).toEqual(['dotnet:Stray.csproj:skippedNoSdk', 'maven:pom.xml:generated'])
+      expect(
+        vi.mocked(runManifestFacts).mock.calls.map(([o]) => o.ecosystem),
+      ).toEqual(['maven'])
+    } finally {
+      await fs.rm(dir, { recursive: true, force: true })
+    }
+  })
+
   it('resolves each build root its own nearest socket.json instead of only the root config', async () => {
     vi.mocked(readSocketJsonCascade).mockImplementation(
       (dir, _boundaryDir, fallback) =>