@commandable/integration-data 0.0.1 → 0.0.4

package/integrations/github/__tests__/get_handlers.test.ts

@@ -1,117 +1,110 @@
 import { beforeAll, describe, expect, it } from 'vitest'
-import { IntegrationProxy } from '../../../src/integrations/proxy.js'
-import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
-
-// LIVE GitHub integration tests using managed OAuth
-// Required env vars:
-// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
-// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
-// - GITHUB_TEST_CONNECTION_ID (managed OAuth connection for provider 'github')
-
-interface Ctx {
-  owner?: string
-  repo?: string
-  issue_number?: number
-}
+import { createCredentialStore, createIntegrationNode, createProxy, createToolbox, hasEnv } from '../../__tests__/liveHarness.js'
 
-const env = process.env as Record<string, string>
-const hasEnv = (...keys: string[]) => keys.every(k => !!env[k] && env[k].trim().length > 0)
-const suite = hasEnv('COMMANDABLE_MANAGED_OAUTH_BASE_URL', 'COMMANDABLE_MANAGED_OAUTH_SECRET_KEY', 'GITHUB_TEST_CONNECTION_ID')
-  ? describe
-  : describe.skip
+// LIVE GitHub read tests -- runs once per available credential variant.
+// Required env vars (at least one):
+// - GITHUB_CLASSIC_PAT
+// - GITHUB_FINE_GRAINED_PAT
 
-suite('github read handlers (live)', () => {
-  const ctx: Ctx = {}
-  let buildHandler: (name: string) => ((input: any) => Promise<any>)
+const env = process.env as Record<string, string | undefined>
 
-  beforeAll(async () => {
-    const { COMMANDABLE_MANAGED_OAUTH_BASE_URL, COMMANDABLE_MANAGED_OAUTH_SECRET_KEY, GITHUB_TEST_CONNECTION_ID } = env
+interface VariantConfig {
+  key: string
+  token: string
+}
 
-    const proxy = new IntegrationProxy({
-      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
-      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
-    })
-    const integrationNode = { id: 'node-github', type: 'github', label: 'GitHub', connectionId: GITHUB_TEST_CONNECTION_ID } as any
+const variants: VariantConfig[] = [
+  { key: 'classic_pat', token: env.GITHUB_CLASSIC_PAT || '' },
+  { key: 'fine_grained_pat', token: env.GITHUB_FINE_GRAINED_PAT || '' },
+].filter(v => v.token.trim().length > 0)
 
-    const tools = loadIntegrationTools('github')
-    expect(tools).toBeTruthy()
+const suiteOrSkip = variants.length > 0 ? describe : describe.skip
 
-    buildHandler = (name: string) => {
-      const tool = tools!.read.find(t => t.name === name)
-      expect(tool, `tool ${name} exists`).toBeTruthy()
-      const integration = {
-        fetch: (path: string, init?: RequestInit) => proxy.call(integrationNode, path, init),
+suiteOrSkip('github read handlers (live)', () => {
+  for (const variant of variants) {
+    describe(`variant: ${variant.key}`, () => {
+      interface Ctx {
+        owner?: string
+        repo?: string
+        issue_number?: number
       }
-      const build = new Function('integration', `return (${tool!.handlerCode});`)
-      return build(integration) as (input: any) => Promise<any>
-    }
-
-    // Discover owner/repo/issue for tests
-    const list_repos = buildHandler('list_repos')
-    const repos = await list_repos({})
-    const first = Array.isArray(repos) ? repos[0] : repos?.[0]
-    ctx.owner = first?.owner?.login || first?.owner || first?.full_name?.split?.('/')[0]
-    ctx.repo = first?.name || first?.full_name?.split?.('/')[1]
-
-    if (ctx.owner && ctx.repo) {
-      const list_issues = buildHandler('list_issues')
-      const issues = await list_issues({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
-      const firstIssue = Array.isArray(issues) ? issues.find((i: any) => typeof i.number === 'number') : undefined
-      ctx.issue_number = firstIssue?.number
-    }
-  }, 60000)
-
-  it('list_repos returns repositories', async () => {
-    const handler = buildHandler('list_repos')
-    const result = await handler({})
-    expect(result).toBeTruthy()
-  }, 30000)
-
-  it('get_repo returns repo details', async () => {
-    if (!ctx.owner || !ctx.repo)
-      return expect(true).toBe(true)
-    const handler = buildHandler('get_repo')
-    const result = await handler({ owner: ctx.owner, repo: ctx.repo })
-    expect(result?.name?.toLowerCase?.()).toBe(ctx.repo?.toLowerCase?.())
-  }, 30000)
-
-  it('list_issues returns issues for repo', async () => {
-    if (!ctx.owner || !ctx.repo)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_issues')
-    const result = await handler({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
-    expect(Array.isArray(result)).toBe(true)
-  }, 30000)
-
-  it('get_issue returns a single issue if available', async () => {
-    if (!ctx.owner || !ctx.repo || !ctx.issue_number)
-      return expect(true).toBe(true)
-    const handler = buildHandler('get_issue')
-    const result = await handler({ owner: ctx.owner, repo: ctx.repo, issue_number: ctx.issue_number })
-    expect(result?.number).toBe(ctx.issue_number)
-  }, 30000)
-
-  it('list_pull_requests returns PRs', async () => {
-    if (!ctx.owner || !ctx.repo)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_pull_requests')
-    const result = await handler({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
-    expect(Array.isArray(result)).toBe(true)
-  }, 30000)
-
-  it('list_branches returns branches', async () => {
-    if (!ctx.owner || !ctx.repo)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_branches')
-    const result = await handler({ owner: ctx.owner, repo: ctx.repo })
-    expect(Array.isArray(result)).toBe(true)
-  }, 30000)
-
-  it('list_commits returns commits', async () => {
-    if (!ctx.owner || !ctx.repo)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_commits')
-    const result = await handler({ owner: ctx.owner, repo: ctx.repo })
-    expect(Array.isArray(result)).toBe(true)
-  }, 30000)
+
+      const ctx: Ctx = {}
+      let toolbox: ReturnType<typeof createToolbox>
+
+      beforeAll(async () => {
+        const credentialStore = createCredentialStore(async () => ({ token: variant.token }))
+        const proxy = createProxy(credentialStore)
+        const node = createIntegrationNode('github', { credentialVariant: variant.key })
+        toolbox = createToolbox('github', proxy, node, variant.key)
+
+        const list_repos = toolbox.read('list_repos')
+        const repos = await list_repos({})
+        const first = Array.isArray(repos) ? repos[0] : undefined
+        ctx.owner = first?.owner?.login || first?.owner || first?.full_name?.split?.('/')[0]
+        ctx.repo = first?.name || first?.full_name?.split?.('/')[1]
+
+        if (ctx.owner && ctx.repo) {
+          const list_issues = toolbox.read('list_issues')
+          const issues = await list_issues({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
+          const firstIssue = Array.isArray(issues) ? issues.find((i: any) => typeof i.number === 'number') : undefined
+          ctx.issue_number = firstIssue?.number
+        }
+      }, 60000)
+
+      it('list_repos returns repositories', async () => {
+        const handler = toolbox.read('list_repos')
+        const result = await handler({})
+        expect(result).toBeTruthy()
+      }, 30000)
+
+      it('get_repo returns repo details', async () => {
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+        const handler = toolbox.read('get_repo')
+        const result = await handler({ owner: ctx.owner, repo: ctx.repo })
+        expect(result?.name?.toLowerCase?.()).toBe(ctx.repo?.toLowerCase?.())
+      }, 30000)
+
+      it('list_issues returns issues for repo', async () => {
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+        const handler = toolbox.read('list_issues')
+        const result = await handler({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
+        expect(Array.isArray(result)).toBe(true)
+      }, 30000)
+
+      it('get_issue returns a single issue if available', async () => {
+        if (!ctx.owner || !ctx.repo || !ctx.issue_number)
+          return expect(true).toBe(true)
+        const handler = toolbox.read('get_issue')
+        const result = await handler({ owner: ctx.owner, repo: ctx.repo, issue_number: ctx.issue_number })
+        expect(result?.number).toBe(ctx.issue_number)
+      }, 30000)
+
+      it('list_pull_requests returns PRs', async () => {
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+        const handler = toolbox.read('list_pull_requests')
+        const result = await handler({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
+        expect(Array.isArray(result)).toBe(true)
+      }, 30000)
+
+      it('list_branches returns branches', async () => {
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+        const handler = toolbox.read('list_branches')
+        const result = await handler({ owner: ctx.owner, repo: ctx.repo })
+        expect(Array.isArray(result)).toBe(true)
+      }, 30000)
+
+      it('list_commits returns commits', async () => {
+        if (!ctx.owner || !ctx.repo)
+          return expect(true).toBe(true)
+        const handler = toolbox.read('list_commits')
+        const result = await handler({ owner: ctx.owner, repo: ctx.repo })
+        expect(Array.isArray(result)).toBe(true)
+      }, 30000)
+    })
+  }
 })

package/integrations/github/__tests__/usage_parity.test.ts

@@ -1,34 +1,22 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { describe, expect, it } from 'vitest'
-import { loadIntegrationManifest } from '../../../src/integrations/dataLoader.js'
-
-function escapeRegExp(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
+import { getMissingToolUsages } from '../../__tests__/usageParity.js'
 
 describe('github static usage parity', () => {
-  it('every manifest tool is referenced in tests via build*(name)', () => {
-    const manifest = loadIntegrationManifest('github')!
-    const toolNames = (manifest.tools as any[]).map(t => t.name)
-
-    const testsDir = fileURLToPath(new URL('.', import.meta.url))
-    expect(existsSync(testsDir)).toBe(true)
-    const testFiles = readdirSync(testsDir)
-      .filter(f => /\.test\.(t|j)s$/.test(f) && !f.includes('usage_parity.test'))
-      .map(f => resolve(testsDir, f))
-
-    const fileContents = testFiles.map(f => readFileSync(f, 'utf8'))
-
-    const missing: string[] = []
-    for (const name of toolNames) {
-      const nameRe = new RegExp(`build(?:Read|Write|Admin)?(?:Handler)?\\(\\s*['"\`]${escapeRegExp(name)}['"\`]\\s*\\)`, 'm')
-      const found = fileContents.some(src => nameRe.test(src))
-      if (!found)
-        missing.push(name)
-    }
+  it('every classic_pat tool is referenced in tests', () => {
+    const missing = getMissingToolUsages({
+      integrationName: 'github',
+      importMetaUrl: import.meta.url,
+      credentialVariant: 'classic_pat',
+    })
+    expect(missing, `Missing handler usages in tests: ${missing.join(', ')}`).toEqual([])
+  })
 
+  it('every fine_grained_pat tool is referenced in tests', () => {
+    const missing = getMissingToolUsages({
+      integrationName: 'github',
+      importMetaUrl: import.meta.url,
+      credentialVariant: 'fine_grained_pat',
+    })
     expect(missing, `Missing handler usages in tests: ${missing.join(', ')}`).toEqual([])
   })
 })