test: add unit tests for core pure helpers and CI

Cover normalizeUrl, provider guessing/resolution, tier partitioning,
GitHub GraphQL query builders, the GitHub sponsors fetcher, and the SVG
composer. Run tests in CI via the shared sxzz workflow and switch the
default test script to non-watch mode.

Author: antfubot

.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: Unit Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions: {}
+
+jobs:
+  unit-test:
+    uses: sxzz/workflows/.github/workflows/unit-test.yml@main
+
+  # coverage:
+  #   uses: sxzz/workflows/.github/workflows/coverage.yml@main
+  #   needs: unit-test
+  #   permissions:
+  #     id-token: write

.github/workflows/lint.yml

@@ -39,7 +39,8 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsx src/cli.ts",
-    "test": "vitest",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "pnpm run build",

package.json

@@ -0,0 +1,73 @@
+import type { Sponsorship, Tier } from '../types.ts'
+import { describe, expect, it } from 'vitest'
+import { partitionTiers } from './index.ts'
+
+function sponsor(login: string, monthlyDollars: number, createdAt: string): Sponsorship {
+  return {
+    sponsor: {
+      type: 'User',
+      login,
+      name: login,
+      avatarUrl: '',
+    },
+    monthlyDollars,
+    createdAt,
+  }
+}
+
+const tiers: Tier[] = [
+  { title: 'Backers' }, // the required zero-dollar tier
+  { title: 'Sponsors', monthlyDollars: 10 },
+  { title: 'Gold', monthlyDollars: 100 },
+]
+
+describe('partitionTiers', () => {
+  it('requires exactly one tier without monthlyDollars', () => {
+    expect(() => partitionTiers([], [{ title: 'a', monthlyDollars: 10 }]))
+      .toThrow('There should be exactly one tier with no `monthlyDollars`, but got 0')
+
+    expect(() => partitionTiers([], [{ title: 'a' }, { title: 'b' }]))
+      .toThrow('There should be exactly one tier with no `monthlyDollars`, but got 2')
+  })
+
+  it('buckets sponsors into the highest tier they qualify for', () => {
+    const sponsors = [
+      sponsor('gold', 100, '2024-01-01'),
+      sponsor('mid', 10, '2024-01-02'),
+      sponsor('small', 5, '2024-01-03'),
+    ]
+
+    const result = partitionTiers(sponsors, tiers)
+
+    // sorted by monthlyDollars descending
+    expect(result.map(t => t.monthlyDollars)).toEqual([100, 10, 0])
+    expect(result[0].sponsors.map(s => s.sponsor.login)).toEqual(['gold'])
+    expect(result[1].sponsors.map(s => s.sponsor.login)).toEqual(['mid'])
+    expect(result[2].sponsors.map(s => s.sponsor.login)).toEqual(['small'])
+  })
+
+  it('excludes past sponsors unless includePastSponsors is set', () => {
+    const sponsors = [
+      sponsor('active', 10, '2024-01-01'),
+      sponsor('past', -1, '2024-01-02'),
+    ]
+
+    const without = partitionTiers(structuredClone(sponsors), tiers)
+    expect(without.flatMap(t => t.sponsors.map(s => s.sponsor.login))).toEqual(['active'])
+
+    const withPast = partitionTiers(structuredClone(sponsors), tiers, true)
+    expect(withPast.flatMap(t => t.sponsors.map(s => s.sponsor.login)).sort())
+      .toEqual(['active', 'past'])
+  })
+
+  it('orders sponsors within a tier by createdAt ascending', () => {
+    const sponsors = [
+      sponsor('later', 10, '2024-03-01'),
+      sponsor('earlier', 10, '2024-01-01'),
+    ]
+
+    const result = partitionTiers(sponsors, tiers)
+    const bucket = result.find(t => t.monthlyDollars === 10)!
+    expect(bucket.sponsors.map(s => s.sponsor.login)).toEqual(['earlier', 'later'])
+  })
+})

src/configs/index.test.ts

@@ -0,0 +1,90 @@
+import type { SponsorkitRenderOptions } from '../types.ts'
+import { describe, expect, it } from 'vitest'
+import { genSvgImage, SvgComposer } from './svg.ts'
+
+function createComposer(width = 800) {
+  return new SvgComposer({
+    width,
+    svgInlineCSS: '.text { fill: red }',
+    imageFormat: 'webp',
+  } as unknown as Required<SponsorkitRenderOptions>)
+}
+
+describe('svgComposer', () => {
+  it('starts empty', () => {
+    const composer = createComposer()
+    expect(composer.height).toBe(0)
+    expect(composer.body).toBe('')
+  })
+
+  it('addText appends centered text and advances the height', () => {
+    const composer = createComposer(800)
+    composer.addText('Hello')
+    expect(composer.height).toBe(20)
+    expect(composer.body).toContain('x="400"')
+    expect(composer.body).toContain('>Hello</text>')
+    expect(composer.body).toContain('class="text"')
+  })
+
+  it('addTitle uses the tier-title class', () => {
+    const composer = createComposer()
+    composer.addTitle('Backers')
+    expect(composer.body).toContain('class="sponsorkit-tier-title"')
+    expect(composer.body).toContain('>Backers</text>')
+  })
+
+  it('addSpan only advances the height', () => {
+    const composer = createComposer()
+    composer.addSpan(42)
+    expect(composer.height).toBe(42)
+    expect(composer.body).toBe('')
+  })
+
+  it('addRaw appends without touching the height', () => {
+    const composer = createComposer()
+    composer.addRaw('<rect />')
+    expect(composer.body).toBe('<rect />')
+    expect(composer.height).toBe(0)
+  })
+
+  it('is chainable', () => {
+    const composer = createComposer()
+    expect(composer.addSpan(10).addText('x')).toBe(composer)
+  })
+
+  it('generateSvg wraps the body with dimensions and inline css', () => {
+    const composer = createComposer(600)
+    composer.addText('Hi')
+    const svg = composer.generateSvg()
+    expect(svg).toContain('viewBox="0 0 600 20"')
+    expect(svg).toContain('width="600"')
+    expect(svg).toContain('height="20"')
+    expect(svg).toContain('<style>.text { fill: red }</style>')
+    expect(svg).toContain('>Hi</text>')
+  })
+})
+
+describe('genSvgImage', () => {
+  it('embeds the image as a base64 data uri', () => {
+    const svg = genSvgImage(1, 2, 40, 0.5, 'QUJD', 'png')
+    expect(svg).toContain('href="data:image/png;base64,QUJD"')
+    expect(svg).toContain('x="1"')
+    expect(svg).toContain('y="2"')
+    expect(svg).toContain('width="40"')
+    expect(svg).toContain('rx="20"') // size * radius
+  })
+
+  it('derives a deterministic clip id that both nodes reference', () => {
+    const first = genSvgImage(0, 0, 40, 0.5, 'SAME', 'webp')
+    const second = genSvgImage(10, 10, 40, 0.5, 'SAME', 'webp')
+
+    const id = first.match(/id="(c[0-9a-f]{6})"/)?.[1]
+    expect(id).toBeDefined()
+    expect(first).toContain(`clip-path="url(#${id})"`)
+    // same image bytes -> same id across calls
+    expect(second).toContain(`id="${id}"`)
+
+    const other = genSvgImage(0, 0, 40, 0.5, 'DIFFERENT', 'webp')
+    expect(other).not.toContain(`id="${id}"`)
+  })
+})

src/processing/svg.test.ts

@@ -0,0 +1,158 @@
+import type { Mock } from 'vitest'
+import type { SponsorkitConfig } from '../types.ts'
+import { $fetch } from 'ofetch'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  fetchGitHubSponsors,
+  makeQuery,
+  makeSponsoringQuery,
+  makeSponsoringTotalAmountQuery,
+} from './github.ts'
+
+vi.mock('ofetch', () => ({ $fetch: vi.fn() }))
+
+const fetchMock = $fetch as unknown as Mock
+
+beforeEach(() => {
+  fetchMock.mockReset()
+})
+
+describe('makeQuery', () => {
+  it('embeds the login and account type', () => {
+    expect(makeQuery('antfu', 'user')).toContain('user(login: "antfu")')
+    expect(makeQuery('antfu', 'organization')).toContain('organization(login: "antfu")')
+  })
+
+  it('queries sponsorships as a maintainer', () => {
+    expect(makeQuery('antfu', 'user')).toContain('sponsorshipsAsMaintainer(')
+  })
+
+  it('interpolates the activeOnly flag', () => {
+    expect(makeQuery('antfu', 'user', true)).toContain('activeOnly: true')
+    expect(makeQuery('antfu', 'user', false)).toContain('activeOnly: false')
+  })
+
+  it('adds an after cursor only when provided', () => {
+    expect(makeQuery('antfu', 'user', true)).not.toContain('after:')
+    expect(makeQuery('antfu', 'user', true, 'CURSOR')).toContain('after: "CURSOR"')
+  })
+})
+
+describe('makeSponsoringQuery', () => {
+  it('queries sponsorships as a sponsor', () => {
+    const query = makeSponsoringQuery('antfu', 'user', false, 'CURSOR')
+    expect(query).toContain('sponsorshipsAsSponsor(')
+    expect(query).toContain('activeOnly: false')
+    expect(query).toContain('after: "CURSOR"')
+  })
+})
+
+describe('makeSponsoringTotalAmountQuery', () => {
+  it('omits parameters when no options are given', () => {
+    const query = makeSponsoringTotalAmountQuery('antfu', 'user')
+    expect(query).toContain('totalSponsorshipAmountAsSponsorInCents\n')
+    expect(query).not.toContain('totalSponsorshipAmountAsSponsorInCents(')
+  })
+
+  it('serializes since, until and sponsorableLogins', () => {
+    const query = makeSponsoringTotalAmountQuery('antfu', 'user', {
+      since: '2024-01-01',
+      until: '2024-12-31',
+      sponsorableLogins: ['vuejs', 'vitejs'],
+    })
+    expect(query).toContain('since: "2024-01-01"')
+    expect(query).toContain('until: "2024-12-31"')
+    expect(query).toContain('sponsorableLogins: ["vuejs", "vitejs"]')
+  })
+})
+
+describe('fetchGitHubSponsors', () => {
+  it('validates its required arguments', async () => {
+    await expect(fetchGitHubSponsors('', 'antfu', 'user', {}))
+      .rejects
+      .toThrow('GitHub token is required')
+    await expect(fetchGitHubSponsors('token', '', 'user', {}))
+      .rejects
+      .toThrow('GitHub login is required')
+    await expect(fetchGitHubSponsors('token', 'antfu', 'invalid' as any, {}))
+      .rejects
+      .toThrow('GitHub type must be either `user` or `organization`')
+  })
+
+  it('paginates and maps the response into sponsorships', async () => {
+    const page = (login: string, hasNextPage: boolean, endCursor: string | null) => ({
+      data: {
+        user: {
+          sponsorshipsAsMaintainer: {
+            totalCount: 2,
+            pageInfo: { hasNextPage, endCursor },
+            nodes: [
+              {
+                createdAt: '2024-01-01T00:00:00Z',
+                privacyLevel: 'PUBLIC',
+                isActive: true,
+                tier: { name: 'Gold', isOneTime: false, monthlyPriceInCents: 1000, monthlyPriceInDollars: 10 },
+                sponsorEntity: { __typename: 'User', login, name: login, avatarUrl: 'a', websiteUrl: 'example.com' },
+              },
+            ],
+          },
+        },
+      },
+    })
+
+    fetchMock
+      .mockResolvedValueOnce(page('alice', true, 'CURSOR'))
+      .mockResolvedValueOnce(page('bob', false, null))
+
+    const sponsors = await fetchGitHubSponsors('token', 'antfu', 'user', {})
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    // second request carries the cursor from the first page
+    expect(fetchMock.mock.calls[1][1].body.query).toContain('after: "CURSOR"')
+
+    expect(sponsors.map(s => s.sponsor.login)).toEqual(['alice', 'bob'])
+    expect(sponsors[0]).toMatchObject({
+      monthlyDollars: 10,
+      tierName: 'Gold',
+      isOneTime: false,
+      sponsor: {
+        login: 'alice',
+        type: 'User',
+        websiteUrl: 'https://example.com',
+        linkUrl: 'https://github.com/alice',
+      },
+    })
+  })
+
+  it('marks inactive non-prorated sponsors as past sponsors', async () => {
+    fetchMock.mockResolvedValueOnce({
+      data: {
+        user: {
+          sponsorshipsAsMaintainer: {
+            totalCount: 1,
+            pageInfo: { hasNextPage: false, endCursor: null },
+            nodes: [
+              {
+                createdAt: '2024-01-01T00:00:00Z',
+                privacyLevel: 'PUBLIC',
+                isActive: false,
+                tier: { name: 'Gold', isOneTime: false, monthlyPriceInCents: 1000, monthlyPriceInDollars: 10 },
+                sponsorEntity: { __typename: 'User', login: 'past', name: 'past', avatarUrl: 'a' },
+              },
+            ],
+          },
+        },
+      },
+    })
+
+    const sponsors = await fetchGitHubSponsors('token', 'antfu', 'user', {})
+    expect(sponsors[0].monthlyDollars).toBe(-1)
+  })
+
+  it('throws when the API returns errors', async () => {
+    fetchMock.mockResolvedValueOnce({ errors: [{ type: 'INSUFFICIENT_SCOPES' }] })
+    await expect(fetchGitHubSponsors('token', 'antfu', 'user', {} as SponsorkitConfig))
+      .rejects
+      .toThrow('read:user')
+  })
+})