relay-ide 0.1.0

package/dist/test/github-graphql.test.js

@@ -0,0 +1,301 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildPrSearchQuery, mapGraphQLResponse, fetchPrsGraphQL, } from '../server/github-graphql.js';
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function makeRepoMap(entries) {
+    return new Map(entries);
+}
+/**
+ * Builds a minimal GraphQL PullRequest node for testing.
+ */
+function makePrNode(overrides) {
+    const { number = 1, title = 'Test PR', state = 'OPEN', isDraft = false, url = 'https://github.com/owner/repo/pull/1', updatedAt = '2026-03-01T00:00:00Z', author = 'testuser', headRefName = 'feat/branch', baseRefName = 'main', nameWithOwner = 'owner/repo', reviewDecision = null, reviewerLogins = [], ciRollupState = null, mergeable = null, additions = 5, deletions = 2, } = overrides;
+    return {
+        number,
+        title,
+        state,
+        isDraft,
+        url,
+        updatedAt,
+        createdAt: updatedAt,
+        author: { login: author },
+        headRefName,
+        baseRefName,
+        repository: { nameWithOwner },
+        reviewDecision,
+        reviewRequests: {
+            nodes: reviewerLogins.map((login) => ({
+                requestedReviewer: { login },
+            })),
+        },
+        commits: {
+            nodes: ciRollupState !== undefined
+                ? [
+                    {
+                        commit: {
+                            statusCheckRollup: ciRollupState
+                                ? { state: ciRollupState }
+                                : null,
+                        },
+                    },
+                ]
+                : [],
+        },
+        mergeable,
+        additions,
+        deletions,
+    };
+}
+function makeGraphQLResponse(prNodes, viewerLogin = 'testuser') {
+    return {
+        data: {
+            search: { nodes: prNodes },
+            viewer: { login: viewerLogin },
+        },
+    };
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+describe('buildPrSearchQuery', () => {
+    test('returns a non-empty query string', () => {
+        const query = buildPrSearchQuery();
+        assert.ok(typeof query === 'string' && query.length > 0, 'query should be a non-empty string');
+    });
+    test('contains key fields: number, title, isDraft, state', () => {
+        const query = buildPrSearchQuery();
+        assert.ok(query.includes('number'), 'query should include "number"');
+        assert.ok(query.includes('title'), 'query should include "title"');
+        assert.ok(query.includes('isDraft'), 'query should include "isDraft"');
+        assert.ok(query.includes('state'), 'query should include "state"');
+    });
+    test('contains CI status rollup field', () => {
+        const query = buildPrSearchQuery();
+        assert.ok(query.includes('statusCheckRollup'), 'query should include "statusCheckRollup"');
+    });
+    test('contains reviewDecision and reviewRequests fields', () => {
+        const query = buildPrSearchQuery();
+        assert.ok(query.includes('reviewDecision'), 'query should include "reviewDecision"');
+        assert.ok(query.includes('reviewRequests'), 'query should include "reviewRequests"');
+    });
+    test('contains repository nameWithOwner field', () => {
+        const query = buildPrSearchQuery();
+        assert.ok(query.includes('nameWithOwner'), 'query should include "nameWithOwner"');
+    });
+    test('contains viewer login field', () => {
+        const query = buildPrSearchQuery();
+        assert.ok(query.includes('viewer'), 'query should include "viewer"');
+        assert.ok(query.includes('login'), 'query should include "login"');
+    });
+});
+describe('mapGraphQLResponse', () => {
+    test('maps PR node fields correctly (number, reviewDecision, ciStatus, isDraft, role, repoName, repoPath)', () => {
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const prNode = makePrNode({
+            number: 42,
+            title: 'My PR',
+            state: 'OPEN',
+            isDraft: false,
+            nameWithOwner: 'owner/repo',
+            reviewDecision: 'APPROVED',
+            ciRollupState: 'SUCCESS',
+        });
+        const response = makeGraphQLResponse([prNode]);
+        const { prs, username } = mapGraphQLResponse(response, repoMap);
+        assert.equal(username, 'testuser');
+        assert.equal(prs.length, 1);
+        const pr = prs[0];
+        assert.equal(pr.number, 42);
+        assert.equal(pr.title, 'My PR');
+        assert.equal(pr.reviewDecision, 'APPROVED');
+        assert.equal(pr.ciStatus, 'SUCCESS');
+        assert.equal(pr.isDraft, false);
+        assert.equal(pr.role, 'author');
+        assert.equal(pr.repoName, 'repo');
+        assert.equal(pr.repoPath, '/workspace/repo');
+    });
+    test('assigns reviewer role when user is in reviewRequests (not author)', () => {
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const prNode = makePrNode({
+            number: 10,
+            author: 'otheruser',
+            nameWithOwner: 'owner/repo',
+            reviewerLogins: ['testuser'],
+        });
+        const response = makeGraphQLResponse([prNode]);
+        const { prs } = mapGraphQLResponse(response, repoMap);
+        assert.equal(prs.length, 1);
+        assert.equal(prs[0].role, 'reviewer');
+        assert.equal(prs[0].author, 'otheruser');
+    });
+    test('skips PRs where user is neither author nor reviewer', () => {
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const prNode = makePrNode({
+            number: 5,
+            author: 'someoneelse',
+            nameWithOwner: 'owner/repo',
+            reviewerLogins: ['anotheruser'],
+        });
+        const response = makeGraphQLResponse([prNode]);
+        const { prs } = mapGraphQLResponse(response, repoMap);
+        assert.equal(prs.length, 0, 'PR where user is neither author nor reviewer should be filtered out');
+    });
+    test('filters out repos not in workspace map', () => {
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const prNode = makePrNode({
+            number: 99,
+            nameWithOwner: 'owner/other-repo', // not in map
+            author: 'testuser',
+        });
+        const response = makeGraphQLResponse([prNode]);
+        const { prs } = mapGraphQLResponse(response, repoMap);
+        assert.equal(prs.length, 0, 'PR from repo not in workspace map should be filtered out');
+    });
+    test('maps ciStatus correctly for all states', () => {
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const testCases = [
+            ['SUCCESS', 'SUCCESS'],
+            ['FAILURE', 'FAILURE'],
+            ['ERROR', 'ERROR'],
+            ['PENDING', 'PENDING'],
+            ['EXPECTED', 'PENDING'],
+            [null, null],
+        ];
+        for (const [rollupState, expectedCiStatus] of testCases) {
+            const prNode = makePrNode({
+                number: 1,
+                nameWithOwner: 'owner/repo',
+                author: 'testuser',
+                ciRollupState: rollupState,
+            });
+            const response = makeGraphQLResponse([prNode]);
+            const { prs } = mapGraphQLResponse(response, repoMap);
+            assert.equal(prs[0].ciStatus, expectedCiStatus, `ciStatus should be ${expectedCiStatus} for rollup state ${rollupState}`);
+        }
+    });
+    test('maps isDraft=true correctly', () => {
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const prNode = makePrNode({
+            number: 7,
+            nameWithOwner: 'owner/repo',
+            author: 'testuser',
+            isDraft: true,
+        });
+        const response = makeGraphQLResponse([prNode]);
+        const { prs } = mapGraphQLResponse(response, repoMap);
+        assert.equal(prs[0].isDraft, true);
+    });
+    test('handles multiple PRs across multiple repos', () => {
+        const repoMap = makeRepoMap([
+            ['owner/repo-a', '/workspace/repo-a'],
+            ['owner/repo-b', '/workspace/repo-b'],
+        ]);
+        const nodes = [
+            makePrNode({
+                number: 1,
+                nameWithOwner: 'owner/repo-a',
+                author: 'testuser',
+            }),
+            makePrNode({
+                number: 2,
+                nameWithOwner: 'owner/repo-b',
+                author: 'testuser',
+            }),
+            makePrNode({
+                number: 3,
+                nameWithOwner: 'owner/unrelated',
+                author: 'testuser',
+            }),
+        ];
+        const response = makeGraphQLResponse(nodes);
+        const { prs } = mapGraphQLResponse(response, repoMap);
+        assert.equal(prs.length, 2);
+        const numbers = prs.map((p) => p.number).sort((a, b) => a - b);
+        assert.deepEqual(numbers, [1, 2]);
+    });
+    test('repoMap lookup is case-insensitive', () => {
+        // Repo map uses lowercase keys; nameWithOwner from GitHub may vary in case
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const prNode = makePrNode({
+            number: 1,
+            nameWithOwner: 'Owner/Repo', // mixed case from API
+            author: 'testuser',
+        });
+        const response = makeGraphQLResponse([prNode]);
+        const { prs } = mapGraphQLResponse(response, repoMap);
+        assert.equal(prs.length, 1, 'Lookup should be case-insensitive');
+    });
+});
+describe('fetchPrsGraphQL', () => {
+    test('calls GitHub GraphQL endpoint with Bearer token', async () => {
+        let capturedUrl;
+        let capturedInit;
+        const mockFetch = async (input, init) => {
+            capturedUrl = input;
+            capturedInit = init;
+            const responseBody = {
+                data: {
+                    search: { nodes: [] },
+                    viewer: { login: 'testuser' },
+                },
+            };
+            return new Response(JSON.stringify(responseBody), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        };
+        const repoMap = makeRepoMap([]);
+        await fetchPrsGraphQL('my-token', repoMap, mockFetch);
+        assert.equal(capturedUrl, 'https://api.github.com/graphql', 'Should call GitHub GraphQL endpoint');
+        assert.ok(capturedInit?.method === 'POST', 'Should use POST method');
+        assert.ok(capturedInit?.headers?.['Authorization'] ===
+            'Bearer my-token', 'Should set Bearer token in Authorization header');
+    });
+    test('throws on 401 Unauthorized response', async () => {
+        const mockFetch = async () => {
+            return new Response('Unauthorized', {
+                status: 401,
+                statusText: 'Unauthorized',
+            });
+        };
+        const repoMap = makeRepoMap([]);
+        await assert.rejects(() => fetchPrsGraphQL('bad-token', repoMap, mockFetch), (err) => {
+            assert.ok(err.message.includes('401'), `Error should mention 401, got: ${err.message}`);
+            return true;
+        });
+    });
+    test('returns mapped prs and username on success', async () => {
+        const prNode = makePrNode({
+            number: 11,
+            nameWithOwner: 'owner/repo',
+            author: 'alice',
+            ciRollupState: 'SUCCESS',
+        });
+        const mockFetch = async () => {
+            const responseBody = {
+                data: {
+                    search: { nodes: [prNode] },
+                    viewer: { login: 'alice' },
+                },
+            };
+            return new Response(JSON.stringify(responseBody), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        };
+        const repoMap = makeRepoMap([['owner/repo', '/workspace/repo']]);
+        const { prs, username } = await fetchPrsGraphQL('token', repoMap, mockFetch);
+        assert.equal(username, 'alice');
+        assert.equal(prs.length, 1);
+        assert.equal(prs[0].number, 11);
+        assert.equal(prs[0].ciStatus, 'SUCCESS');
+    });
+    test('throws when response has errors but no data (expired token / bad credentials)', async () => {
+        const mockFetch = async () => {
+            return new Response(JSON.stringify({ errors: [{ message: 'Bad credentials' }] }), { status: 200, headers: { 'Content-Type': 'application/json' } });
+        };
+        const repoMap = makeRepoMap([]);
+        await assert.rejects(() => fetchPrsGraphQL('expired-token', repoMap, mockFetch), (err) => {
+            assert.ok(err.message.includes('Bad credentials'), `Error should include "Bad credentials", got: ${err.message}`);
+            return true;
+        });
+    });
+});

package/dist/test/greetings.test.js

@@ -0,0 +1,83 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { getGreeting } from '../frontend/src/lib/greetings.js';
+const morningGreetings = [
+    'good morning',
+    'rise and shine',
+    'early bird gets the worm',
+    'coffee first, code second',
+];
+const afternoonGreetings = [
+    'good afternoon',
+    "it's high noon",
+    'afternoon shift',
+    'back at it',
+];
+const eveningGreetings = [
+    'good evening',
+    'evening shift',
+    'winding down... or ramping up?',
+];
+const nightGreetings = [
+    'good evening',
+    'burning the midnight oil',
+    'the witching hour',
+    'night owl mode',
+    'the city sleeps but the terminal glows',
+];
+const allGreetings = [
+    ...morningGreetings,
+    ...afternoonGreetings,
+    ...eveningGreetings,
+    ...nightGreetings,
+];
+describe('greetings', () => {
+    it('returns a non-empty string', () => {
+        const greeting = getGreeting();
+        assert.ok(greeting.length > 0, 'greeting should be non-empty');
+    });
+    it('returns all lowercase text', () => {
+        for (let i = 0; i < 20; i++) {
+            const greeting = getGreeting();
+            assert.strictEqual(greeting, greeting.toLowerCase(), `greeting "${greeting}" should be lowercase`);
+        }
+    });
+    it('returns a known greeting when called without hour', () => {
+        for (let i = 0; i < 20; i++) {
+            const greeting = getGreeting();
+            assert.ok(allGreetings.includes(greeting), `unexpected greeting: "${greeting}"`);
+        }
+    });
+    it('returns morning greetings for hours 5-11', () => {
+        for (const hour of [5, 8, 11]) {
+            for (let i = 0; i < 20; i++) {
+                const greeting = getGreeting(hour);
+                assert.ok(morningGreetings.includes(greeting), `hour ${hour}: expected morning greeting, got "${greeting}"`);
+            }
+        }
+    });
+    it('returns afternoon greetings for hours 12-16', () => {
+        for (const hour of [12, 14, 16]) {
+            for (let i = 0; i < 20; i++) {
+                const greeting = getGreeting(hour);
+                assert.ok(afternoonGreetings.includes(greeting), `hour ${hour}: expected afternoon greeting, got "${greeting}"`);
+            }
+        }
+    });
+    it('returns evening greetings for hours 17-20', () => {
+        for (const hour of [17, 19, 20]) {
+            for (let i = 0; i < 20; i++) {
+                const greeting = getGreeting(hour);
+                assert.ok(eveningGreetings.includes(greeting), `hour ${hour}: expected evening greeting, got "${greeting}"`);
+            }
+        }
+    });
+    it('returns night greetings for hours 21-4', () => {
+        for (const hour of [0, 2, 4, 21, 23]) {
+            for (let i = 0; i < 20; i++) {
+                const greeting = getGreeting(hour);
+                assert.ok(nightGreetings.includes(greeting), `hour ${hour}: expected night greeting, got "${greeting}"`);
+            }
+        }
+    });
+});