@davidwells/extract-deps 0.0.5 → 0.0.7

package/tests/verify-package-entries.test.js

@@ -0,0 +1,272 @@
+// Test package.json entry point verification
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const path = require('path')
+const { getPackageEntryPoints, verifyPackageEntries, collectEntryPoints } = require('../src/verify-package-entries')
+
+const CJS_EXAMPLE_PKG = path.resolve(__dirname, './fixtures/cjs-example/package.json')
+const ESM_FIXTURE_PKG = path.resolve(__dirname, './fixtures/esm-fixture/package.json')
+const CJS_DEEP_EXAMPLE_PKG = path.resolve(__dirname, './fixtures/cjs-deep-example/package.json')
+
+const packageStub = {
+  "name": "my-package",
+  "version": "1.0.0",
+  "description": "Example package with all entry points",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "browser": "./dist/browser.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "my-cli": "./bin/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "browser": "./dist/browser.js"
+    },
+    "./dep-graph": "./src/dep-graph.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ]
+}
+
+test('getPackageEntryPoints should extract all entry points from package.json', () => {
+  const entryPoints = collectEntryPoints(packageStub, 'dir-path')
+  console.log('entryPoints', entryPoints)
+  assert.ok(Array.isArray(entryPoints), 'Should return an array')
+  assert.ok(entryPoints.length > 0, 'Should have at least one entry point')
+})
+
+// getPackageEntryPoints tests
+test('getPackageEntryPoints should extract main field', () => {
+  const entryPoints = getPackageEntryPoints(CJS_EXAMPLE_PKG)
+  console.log('entryPoints', entryPoints)
+
+  assert.ok(Array.isArray(entryPoints), 'Should return an array')
+  assert.ok(entryPoints.length > 0, 'Should have at least one entry point')
+
+  const mainEntry = entryPoints.find(ep => ep.field === 'main')
+  assert.ok(mainEntry, 'Should have main entry point')
+  assert.is(mainEntry.path, './index.js', 'Main path should be ./index.js')
+})
+
+test('getPackageEntryPoints should extract multiple fields', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const fields = entryPoints.map(ep => ep.field)
+  assert.ok(fields.includes('main'), 'Should include main')
+  assert.ok(fields.includes('module'), 'Should include module')
+})
+
+test('getPackageEntryPoints should extract exports field', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const exportsEntry = entryPoints.find(ep => ep.field.startsWith('exports'))
+  assert.ok(exportsEntry, 'Should have exports entry point')
+})
+
+test('getPackageEntryPoints should handle complex exports with conditionals', () => {
+  const entryPoints = getPackageEntryPoints(CJS_DEEP_EXAMPLE_PKG)
+
+  const fields = entryPoints.map(ep => ep.field)
+
+  // Should extract conditional exports
+  assert.ok(fields.some(f => f.includes('require')), 'Should extract require conditional')
+  assert.ok(fields.some(f => f.includes('import')), 'Should extract import conditional')
+})
+
+test('getPackageEntryPoints should skip .d.ts files', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const hasDts = entryPoints.some(ep => ep.path.endsWith('.d.ts'))
+  assert.not(hasDts, 'Should not include .d.ts files')
+})
+
+test('getPackageEntryPoints should skip .json files', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const hasJson = entryPoints.some(ep => ep.path.endsWith('.json'))
+  assert.not(hasJson, 'Should not include .json files')
+})
+
+test('getPackageEntryPoints should resolve absolute paths', () => {
+  const entryPoints = getPackageEntryPoints(CJS_EXAMPLE_PKG)
+
+  entryPoints.forEach(ep => {
+    assert.ok(path.isAbsolute(ep.resolvedPath), 'Resolved path should be absolute')
+  })
+})
+
+test('getPackageEntryPoints should extract nested exports', () => {
+  const entryPoints = getPackageEntryPoints(CJS_DEEP_EXAMPLE_PKG)
+
+  const fields = entryPoints.map(ep => ep.field)
+
+  // Should have nested paths like exports./one, exports./sub
+  assert.ok(fields.some(f => f.includes('one')), 'Should extract nested export "./one"')
+  assert.ok(fields.some(f => f.includes('sub')), 'Should extract nested export "./sub"')
+})
+
+// verifyPackageEntries tests
+test('verifyPackageEntries should return correct structure', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+  console.log('results', results)
+
+  assert.ok(results.entryPoints, 'Should have entryPoints')
+  assert.ok(results.sourceFiles, 'Should have sourceFiles')
+  assert.ok(results.errors, 'Should have errors')
+
+  assert.ok(Array.isArray(results.entryPoints), 'entryPoints should be array')
+  assert.ok(results.sourceFiles instanceof Set, 'sourceFiles should be Set')
+  assert.ok(Array.isArray(results.errors), 'errors should be array')
+})
+
+test('verifyPackageEntries should verify valid entry points', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  const validCount = results.entryPoints.filter(ep => ep.valid).length
+  assert.ok(validCount > 0, 'Should have at least one valid entry point')
+})
+
+test('verifyPackageEntries should collect dependencies by default', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  results.entryPoints.forEach(ep => {
+    if (ep.valid) {
+      assert.ok(ep.sourceFiles, 'Valid entry should have sourceFiles')
+      assert.ok(Array.isArray(ep.sourceFiles), 'sourceFiles should be array')
+    }
+  })
+})
+
+test('verifyPackageEntries should deduplicate dependencies in sourceFiles', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  // Count total sourceFiles from all entry points
+  let totalDeps = 0
+  results.entryPoints.forEach(ep => {
+    if (ep.sourceFiles) {
+      totalDeps += ep.sourceFiles.length
+    }
+  })
+
+  // sourceFiles should be less than or equal to total (deduplication)
+  assert.ok(results.sourceFiles.size <= totalDeps, 'sourceFiles should deduplicate')
+})
+
+test('verifyPackageEntries should work with collectDeps option', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { collectDeps: true })
+
+  assert.ok(results.sourceFiles.size > 0, 'Should collect dependencies')
+})
+
+test('verifyPackageEntries should skip sourceFiles when collectDeps is false', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { collectDeps: false })
+  console.log('results', results)
+  results.entryPoints.forEach(ep => {
+    console.log('ep', ep)
+    assert.equal(ep.sourceFiles, [], 'Should not collect sourceFiles when collectDeps is false')
+  })
+
+  assert.is(results.sourceFiles.size, 0, 'sourceFiles should be empty')
+})
+
+test('verifyPackageEntries should work with verifyGraph option', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { verifyGraph: true })
+
+  // Should complete without throwing
+  assert.ok(results, 'Should return results')
+})
+
+test('verifyPackageEntries should skip verification when verifyGraph is false', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { verifyGraph: false })
+
+  // Should still collect sourceFiles but skip verification
+  assert.ok(results.sourceFiles.size > 0, 'Should still collect sourceFiles')
+})
+
+test('verifyPackageEntries should collect all errors', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  // With valid fixtures, should have 0 errors
+  assert.is(results.errors.length, 0, 'Valid fixtures should have no errors')
+})
+
+test('verifyPackageEntries should mark entry as invalid on error', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  results.entryPoints.forEach(ep => {
+    if (!ep.valid) {
+      assert.ok(ep.error, 'Invalid entry should have error')
+    }
+  })
+})
+
+test('verifyPackageEntries should process all entries even if one fails', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  // Should process all 6 entry points from deep example
+  assert.ok(results.entryPoints.length >= 6, 'Should process all entry points')
+})
+
+test('verifyPackageEntries should collect sourceFiles for each entry separately', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  const validEntries = results.entryPoints.filter(ep => ep.valid)
+
+  validEntries.forEach(ep => {
+    assert.ok(ep.sourceFiles, 'Each entry should have its own sourceFiles')
+    assert.ok(Array.isArray(ep.sourceFiles), 'sourceFiles should be array')
+    assert.ok(ep.sourceFiles.length > 0, 'sourceFiles should not be empty')
+  })
+})
+
+test('verifyPackageEntries should work with simple package', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  assert.is(results.errors.length, 0, 'Should have no errors')
+  assert.ok(results.sourceFiles.size > 0, 'Should have dependencies')
+})
+
+test('verifyPackageEntries should work with ESM package', () => {
+  const results = verifyPackageEntries(ESM_FIXTURE_PKG)
+
+  assert.is(results.errors.length, 0, 'Should have no errors')
+  assert.ok(results.sourceFiles.size > 0, 'Should have dependencies')
+})
+
+test('verifyPackageEntries should work with complex package', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  assert.is(results.errors.length, 0, 'Should have no errors')
+  assert.ok(results.sourceFiles.size > 0, 'Should have dependencies')
+  assert.ok(results.entryPoints.length >= 6, 'Should have multiple entry points')
+})
+
+test('verifyPackageEntries should include entry point file in sourceFiles', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  const mainEntry = results.entryPoints.find(ep => ep.field === 'main')
+  assert.ok(mainEntry, 'Should have main entry')
+  assert.ok(mainEntry.sourceFiles, 'Should have sourceFiles')
+
+  // Entry point file should be in its sourceFiles (as it's the last file in build order)
+  const hasEntryInDeps = mainEntry.sourceFiles.some(dep => dep === mainEntry.resolvedPath)
+  assert.ok(hasEntryInDeps, 'Entry point should be in its own sourceFiles list')
+})
+
+test('verifyPackageEntries should collect unique sourceFiles across all entries', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  const sourceFilesArray = Array.from(results.sourceFiles)
+  const uniqueDeps = [...new Set(sourceFilesArray)]
+
+  assert.is(sourceFilesArray.length, uniqueDeps.length, 'sourceFiles should not have duplicates')
+})
+
+test.run()