mikser-io-git 2.1.0 → 2.3.0

package/test/forge/github.test.js

@@ -1,70 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ensurePR, mergePR } from '../../lib/forge/github.js'
-
-function fakeResponse({ ok = true, status = 200, body = {} } = {}) {
-    return {
-        ok,
-        status,
-        statusText: ok ? 'OK' : 'Error',
-        json: async () => body,
-    }
-}
-
-const CTX = { owner: 'org', repo: 'content', head: 'mikser', base: 'main', title: 'Promote', token: 'tok' }
-
-describe('github forge adapter', () => {
-    it('ensurePR reuses an existing open PR instead of creating a new one', async () => {
-        const calls = []
-        const fetchImpl = async (url, opts) => {
-            calls.push({ url, method: opts?.method ?? 'GET' })
-            return fakeResponse({ body: [{ number: 7, html_url: 'https://github.com/org/content/pull/7' }] })
-        }
-        const pr = await ensurePR({ ...CTX, fetchImpl })
-        assert.deepEqual(pr, { number: 7, url: 'https://github.com/org/content/pull/7' })
-        assert.equal(calls.length, 1, 'must not call the create endpoint when one already exists')
-        assert.match(calls[0].url, /head=org:mikser&base=main&state=open/)
-    })
-
-    it('ensurePR creates a new PR when none is open', async () => {
-        const calls = []
-        const fetchImpl = async (url, opts) => {
-            calls.push({ url, method: opts?.method ?? 'GET' })
-            if (!opts?.method || opts.method === 'GET') return fakeResponse({ body: [] })
-            return fakeResponse({ status: 201, body: { number: 9, html_url: 'https://github.com/org/content/pull/9' } })
-        }
-        const pr = await ensurePR({ ...CTX, fetchImpl })
-        assert.deepEqual(pr, { number: 9, url: 'https://github.com/org/content/pull/9' })
-        assert.equal(calls.length, 2)
-        assert.equal(calls[1].method, 'POST')
-    })
-
-    it('ensurePR throws with a readable message when creation fails', async () => {
-        const fetchImpl = async (url, opts) => {
-            if (!opts?.method) return fakeResponse({ body: [] })
-            return fakeResponse({ ok: false, status: 422, body: { message: 'Validation failed' } })
-        }
-        await assert.rejects(ensurePR({ ...CTX, fetchImpl }), /Validation failed/)
-    })
-
-    it('mergePR reports merged:true on success', async () => {
-        const fetchImpl = async () => fakeResponse({ body: { merged: true, sha: 'abc' } })
-        const result = await mergePR({ owner: 'org', repo: 'content', number: 7, token: 'tok', fetchImpl })
-        assert.deepEqual(result, { merged: true })
-    })
-
-    it('mergePR reports merged:false with a reason on conflict', async () => {
-        const fetchImpl = async () => fakeResponse({ ok: false, status: 405, body: { message: 'Pull Request is not mergeable' } })
-        const result = await mergePR({ owner: 'org', repo: 'content', number: 7, token: 'tok', fetchImpl })
-        assert.equal(result.merged, false)
-        assert.match(result.reason, /not mergeable/)
-    })
-
-    it('mergePR falls back to statusText when the error body is not JSON', async () => {
-        const fetchImpl = async () => ({ ok: false, status: 500, statusText: 'Internal Server Error', json: async () => { throw new Error('not json') } })
-        const result = await mergePR({ owner: 'org', repo: 'content', number: 7, token: 'tok', fetchImpl })
-        assert.equal(result.merged, false)
-        assert.equal(result.reason, 'Internal Server Error')
-    })
-})

package/test/git.test.js

@@ -1,220 +0,0 @@
-// isNonFastForwardError is pure string-matching, tested directly.
-// Everything else in lib/git.js is a thin execFile wrapper — real
-// confidence there comes from exercising it against an actual git
-// repo in a temp directory. This only covers the LOCAL-only
-// operations (init, add, commit, status, branch) — clone/fetch/push
-// need a real remote and are exercised by hand against a real forge,
-// not in this suite.
-
-import { describe, it, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import path from 'node:path'
-
-import * as git from '../lib/git.js'
-
-describe('isNonFastForwardError', () => {
-    it('recognizes the common rejection messages', () => {
-        assert.ok(git.isNonFastForwardError({ stderr: '! [rejected] main -> main (non-fast-forward)' }))
-        assert.ok(git.isNonFastForwardError({ message: 'failed to push some refs (fetch first)' }))
-        assert.ok(git.isNonFastForwardError({ stderr: 'Updates were rejected because the tip of your current branch is behind' }))
-    })
-
-    it('does not misclassify an unrelated error', () => {
-        assert.equal(git.isNonFastForwardError({ message: 'fatal: repository not found' }), false)
-    })
-
-    it('handles a bare/malformed error object without throwing', () => {
-        assert.equal(git.isNonFastForwardError({}), false)
-        assert.equal(git.isNonFastForwardError(null), false)
-    })
-})
-
-describe('git.js against a real local repo', () => {
-    let dir
-
-    before(async () => {
-        dir = await mkdtemp(path.join(tmpdir(), 'mikser-git-'))
-        await git.run(dir, ['init', '-b', 'main'])
-        // Local-only identity so commit() works in a sandboxed CI
-        // environment with no global git user configured.
-        await git.run(dir, ['config', 'user.email', 'test@example.com'])
-        await git.run(dir, ['config', 'user.name', 'Test'])
-    })
-
-    after(async () => {
-        await rm(dir, { recursive: true, force: true })
-    })
-
-    it('an empty repo has no changes', async () => {
-        assert.equal(await git.hasChanges(dir), false)
-    })
-
-    it('a new file registers as a change', async () => {
-        await writeFile(path.join(dir, 'a.md'), 'hello')
-        assert.equal(await git.hasChanges(dir), true)
-        const status = await git.statusPorcelain(dir)
-        assert.match(status, /a\.md/)
-    })
-
-    it('addAll stages it, then commit records it', async () => {
-        await git.addAll(dir)
-        assert.equal(await git.hasStagedChanges(dir), true)
-        await git.commit(dir, 'first commit')
-        assert.equal(await git.hasChanges(dir), false)
-        assert.equal(await git.hasStagedChanges(dir), false)
-    })
-
-    it('currentBranch reports the init branch', async () => {
-        assert.equal(await git.currentBranch(dir), 'main')
-    })
-
-    it('checkoutBranch creates and switches to a new branch', async () => {
-        await git.checkoutBranch(dir, 'mikser', { create: true })
-        assert.equal(await git.currentBranch(dir), 'mikser')
-        assert.equal(await git.branchExistsLocal(dir, 'mikser'), true)
-        assert.equal(await git.branchExistsLocal(dir, 'nonexistent'), false)
-    })
-
-    it('a second file + commit round-trips through the same flow on the new branch', async () => {
-        await writeFile(path.join(dir, 'b.md'), 'world')
-        await git.addAll(dir)
-        await git.commit(dir, 'second commit')
-        assert.equal(await git.hasChanges(dir), false)
-        assert.equal(await git.revParse(dir, 'HEAD') !== '', true)
-    })
-
-    it('resetHard moves the branch tip and the working tree together', async () => {
-        const beforeReset = await git.revParse(dir, 'HEAD')
-        await writeFile(path.join(dir, 'c.md'), 'discard me')
-        await git.addAll(dir)
-        await git.commit(dir, 'to be discarded')
-        assert.notEqual(await git.revParse(dir, 'HEAD'), beforeReset)
-        await git.resetHard(dir, beforeReset)
-        assert.equal(await git.revParse(dir, 'HEAD'), beforeReset)
-    })
-})
-
-// The hard scope boundary the working-folder-as-checkout model depends
-// on: mikser.config.js, node_modules/, runtime/, out/, .env can live in
-// the SAME checkout this plugin manages, alongside collections it
-// SHOULD auto-commit (documents/, layouts/), as long as every git
-// operation is scoped to `paths`. Proven directly here, not assumed.
-describe('git.js pathspec scoping (paths param)', () => {
-    let dir
-
-    before(async () => {
-        dir = await mkdtemp(path.join(tmpdir(), 'mikser-git-scope-'))
-        await git.run(dir, ['init', '-b', 'main'])
-        await git.run(dir, ['config', 'user.email', 'test@example.com'])
-        await git.run(dir, ['config', 'user.name', 'Test'])
-        await mkdir(path.join(dir, 'documents'))
-        await mkdir(path.join(dir, 'node_modules'))
-        await writeFile(path.join(dir, 'mikser.config.js'), 'export default {}')
-        await writeFile(path.join(dir, 'documents', 'post.md'), 'hello')
-        await writeFile(path.join(dir, 'node_modules', 'dep.js'), 'module.exports = {}')
-        await git.addAll(dir)   // baseline commit — everything present so far
-        await git.commit(dir, 'baseline')
-    })
-
-    after(async () => {
-        await rm(dir, { recursive: true, force: true })
-    })
-
-    it('statusPorcelain with paths only reports changes inside the scope', async () => {
-        await writeFile(path.join(dir, 'documents', 'post.md'), 'edited')          // in scope
-        await writeFile(path.join(dir, 'mikser.config.js'), 'export default { x: 1 }')  // OUT of scope
-        await writeFile(path.join(dir, 'node_modules', 'dep.js'), 'changed')        // OUT of scope
-
-        const scoped = await git.statusPorcelain(dir, ['documents'])
-        assert.match(scoped, /post\.md/)
-        assert.doesNotMatch(scoped, /mikser\.config\.js/)
-        assert.doesNotMatch(scoped, /dep\.js/)
-
-        // Unscoped status proves the OTHER files really were dirty —
-        // the scoped call above wasn't just quiet because nothing changed.
-        const unscoped = await git.statusPorcelain(dir)
-        assert.match(unscoped, /mikser\.config\.js/)
-        assert.match(unscoped, /dep\.js/)
-    })
-
-    it('addAll with paths stages only the in-scope file — the config edit stays untracked', async () => {
-        await git.addAll(dir, ['documents'])
-        assert.equal(await git.hasStagedChanges(dir, ['documents']), true)
-        // Prove mikser.config.js's edit was NOT staged: the unscoped
-        // status must still show it as an unstaged modification (' M'),
-        // not staged ('M ').
-        const status = await git.statusPorcelain(dir)
-        assert.match(status, / M mikser\.config\.js/)
-        assert.doesNotMatch(status, /^M {2}mikser\.config\.js/m)
-
-        await git.commit(dir, 'documents-only change')
-
-        // The committed tree must NOT include the config edit or the
-        // node_modules change — only documents/post.md's new content.
-        const committed = await git.run(dir, ['show', '--stat', 'HEAD'])
-        assert.match(committed, /documents\/post\.md/)
-        assert.doesNotMatch(committed, /mikser\.config\.js/)
-        assert.doesNotMatch(committed, /dep\.js/)
-    })
-
-    it('a brand-new directory outside paths is invisible to a scoped add, even with --untracked-files=all', async () => {
-        await mkdir(path.join(dir, 'layouts'))
-        await writeFile(path.join(dir, 'layouts', 'post.hbs'), '<html></html>')
-
-        await git.addAll(dir, ['documents'])   // layouts/ deliberately not in scope
-        assert.equal(await git.hasStagedChanges(dir, ['documents']), false, 'nothing new in documents/ this round')
-        assert.equal(await git.hasStagedChanges(dir, ['layouts']), false, 'layouts/ was never staged — out of scope')
-
-        const unscoped = await git.statusPorcelain(dir)
-        assert.match(unscoped, /layouts\//)   // still genuinely untracked, just untouched by the scoped add
-    })
-})
-
-// The zero-config default (index.js's `paths` config omitted → resolveConfig
-// gives `null`): with NO pathspec at all, git.js's functions operate on the
-// whole repo. This proves the actual behavior that default implies —
-// something outside any collection folder DOES get staged when no `paths`
-// was configured, and .gitignore (not a pathspec) is what would keep
-// node_modules/.env out in that case. Distinct from the scoped-paths suite
-// above, which proves the OPPOSITE guarantee when paths IS given.
-describe('git.js with paths=null (the no-`paths`-configured default)', () => {
-    let dir
-
-    before(async () => {
-        dir = await mkdtemp(path.join(tmpdir(), 'mikser-git-noscope-'))
-        await git.run(dir, ['init', '-b', 'main'])
-        await git.run(dir, ['config', 'user.email', 'test@example.com'])
-        await git.run(dir, ['config', 'user.name', 'Test'])
-        await writeFile(path.join(dir, '.gitignore'), 'ignored-dir/\n')
-        await mkdir(path.join(dir, 'documents'))
-        await mkdir(path.join(dir, 'ignored-dir'))
-        await writeFile(path.join(dir, 'documents', 'post.md'), 'hello')
-        await writeFile(path.join(dir, 'mikser.config.js'), 'export default {}')
-        await writeFile(path.join(dir, 'ignored-dir', 'dep.js'), 'x')
-        await git.addAll(dir)   // no paths arg — baseline covers everything not gitignored
-        await git.commit(dir, 'baseline')
-    })
-
-    after(async () => {
-        await rm(dir, { recursive: true, force: true })
-    })
-
-    it('with no paths arg, an edit OUTSIDE any collection folder still gets staged', async () => {
-        await writeFile(path.join(dir, 'mikser.config.js'), 'export default { changed: true }')
-        await git.addAll(dir)   // no paths — the default-config behavior
-        assert.equal(await git.hasStagedChanges(dir), true)
-        const status = await git.statusPorcelain(dir)
-        assert.match(status, /^M {2}mikser\.config\.js/m)   // staged, not just modified
-    })
-
-    it('.gitignore, not a pathspec, is what keeps an ignored directory out — even unscoped', async () => {
-        await writeFile(path.join(dir, 'ignored-dir', 'dep.js'), 'changed')
-        await git.addAll(dir)
-        // The gitignored file's change never shows up at all, scoped or not —
-        // this is .gitignore doing the work, since there's no pathspec here.
-        const status = await git.statusPorcelain(dir)
-        assert.doesNotMatch(status, /dep\.js/)
-    })
-})

package/test/repo-url.test.js

@@ -1,35 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { parseRepoUrl } from '../lib/repo-url.js'
-
-describe('parseRepoUrl', () => {
-    it('parses a github.com URL and defaults apiOrigin to api.github.com', () => {
-        const r = parseRepoUrl('https://github.com/almero-digital-marketing/gpoint-content.git')
-        assert.deepEqual(r, { owner: 'almero-digital-marketing', repo: 'gpoint-content', apiOrigin: 'https://api.github.com' })
-    })
-
-    it('parses without the .git suffix identically', () => {
-        const r = parseRepoUrl('https://github.com/org/repo')
-        assert.equal(r.owner, 'org')
-        assert.equal(r.repo, 'repo')
-    })
-
-    it('a self-hosted Gitea URL uses its own origin as apiOrigin (adapter appends /api/v1)', () => {
-        const r = parseRepoUrl('https://git.almero.bg/org/content.git')
-        assert.deepEqual(r, { owner: 'org', repo: 'content', apiOrigin: 'https://git.almero.bg' })
-    })
-
-    it('tolerates a trailing slash', () => {
-        const r = parseRepoUrl('https://git.almero.bg/org/content/')
-        assert.equal(r.repo, 'content')
-    })
-
-    it('throws on a URL with no owner/repo path', () => {
-        assert.throws(() => parseRepoUrl('https://github.com/'), /cannot derive owner\/repo/)
-    })
-
-    it('throws on garbage input', () => {
-        assert.throws(() => parseRepoUrl('not a url'), /not a valid URL/)
-    })
-})