snapshot of https://github.com/ueberdosis/tiptap.git (main, 2026-09-15; blobs > 131072B omitted)

.github/scripts/__tests__/resolve-publish-config.test.mjs

@@ -0,0 +1,128 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync, writeFileSync, mkdtempSync, rmSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { resolveConfig } from '../resolve-publish-config.mjs'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const ACTUAL_CONFIG_PATH = join(__dirname, '..', '..', 'publish-config.json')
+
+let tmpDir
+let configPath
+
+before(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'publish-config-test-'))
+  configPath = join(tmpDir, 'publish-config.json')
+})
+
+after(() => {
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+function writeConfig(data) {
+  writeFileSync(configPath, JSON.stringify(data, null, 2))
+}
+
+describe('real publish-config.json', () => {
+  let actualConfig
+
+  before(() => {
+    const raw = readFileSync(ACTUAL_CONFIG_PATH, 'utf8')
+    actualConfig = JSON.parse(raw)
+  })
+
+  it('is valid JSON and contains a branches object', () => {
+    assert.ok(actualConfig.branches, 'missing branches object')
+    assert.ok(typeof actualConfig.branches === 'object', 'branches must be an object')
+  })
+
+  it('has at least one configured branch', () => {
+    const names = Object.keys(actualConfig.branches)
+    assert.ok(names.length > 0, 'publish-config.json has no branches configured')
+  })
+
+  it('every branch entry has all required string fields', () => {
+    const required = ['distTag', 'label', 'title', 'commit']
+    for (const [name, entry] of Object.entries(actualConfig.branches)) {
+      for (const field of required) {
+        assert.ok(
+          entry[field] && typeof entry[field] === 'string',
+          `Branch "${name}" is missing required string field "${field}"`,
+        )
+      }
+    }
+  })
+
+  it('resolves each configured branch through the resolver', () => {
+    for (const name of Object.keys(actualConfig.branches)) {
+      const result = resolveConfig(name, ACTUAL_CONFIG_PATH)
+      assert.equal(result.configured, true, `Branch "${name}" should resolve as configured`)
+      assert.equal(result.distTag, actualConfig.branches[name].distTag)
+      assert.equal(result.label, actualConfig.branches[name].label)
+      assert.equal(result.title, actualConfig.branches[name].title)
+      assert.equal(result.commit, actualConfig.branches[name].commit)
+    }
+  })
+})
+
+describe('unknown branches', () => {
+  it('returns configured=false for a branch with no entry', () => {
+    writeConfig({
+      branches: { known: { distTag: 'x', label: 'stable', title: 'T', commit: 'c' } },
+    })
+    const result = resolveConfig('unknown', configPath)
+    assert.equal(result.configured, false)
+  })
+
+  it('does not match partial branch names', () => {
+    writeConfig({
+      branches: { main: { distTag: 'x', label: 'stable', title: 'T', commit: 'c' } },
+    })
+    const result = resolveConfig('main-foo', configPath)
+    assert.equal(result.configured, false)
+  })
+
+  it('returns only configured=false for an unknown branch', () => {
+    writeConfig({ branches: {} })
+    const result = resolveConfig('anything', configPath)
+    assert.deepEqual(result, { configured: false })
+  })
+})
+
+describe('validation errors', () => {
+  it('fails when a required field is missing', () => {
+    writeConfig({ branches: { main: { distTag: 'latest', label: 'stable' } } })
+    assert.throws(() => resolveConfig('main', configPath), /missing required/i)
+  })
+
+  it('fails when a required field is not a string', () => {
+    writeConfig({
+      branches: { main: { distTag: 'latest', label: 123, title: null, commit: 'ok' } },
+    })
+    assert.throws(() => resolveConfig('main', configPath), /missing required/i)
+  })
+
+  it('fails when config has no branches object', () => {
+    writeConfig({})
+    assert.throws(() => resolveConfig('main', configPath), /branches/)
+  })
+
+  it('fails when branches is an array instead of an object', () => {
+    writeConfig({ branches: [] })
+    assert.throws(() => resolveConfig('any', configPath), /branches/)
+  })
+
+  it('fails when config file is malformed JSON', () => {
+    writeFileSync(configPath, 'not-json')
+    assert.throws(() => resolveConfig('main', configPath), /Failed to read or parse/)
+  })
+
+  it('fails when config file does not exist', () => {
+    assert.throws(
+      () => resolveConfig('main', join(tmpDir, 'nonexistent.json')),
+      /Failed to read or parse/,
+    )
+  })
+})