sync-engine.test.mjs

import test from 'node:test';
import assert from 'node:assert/strict';
import { stableHash } from './hash.mjs';
import { syncOnce } from './sync-engine.mjs';

function config() {
  return {
    properties: {
      title: 'Title',
      requestType: 'Request Type',
      description: 'Description',
      businessContext: 'Business Context',
      acceptanceCriteria: 'Acceptance Criteria',
      requesterName: 'Requester Name',
      requesterEmail: 'Requester Email',
      company: 'Company',
      businessPriority: 'Business Priority',
      requesterFollowUp: 'Requester Follow-up',
      sendFollowUp: 'Send Follow-up',
      githubIssueUrl: 'GitHub Issue URL',
      githubIssueNumber: 'GitHub Issue Number',
      githubIssueNodeId: 'GitHub Issue Node ID',
      githubState: 'GitHub State',
      githubStateReason: 'GitHub State Reason',
      githubLabels: 'GitHub Labels',
      githubAssignee: 'GitHub Assignee',
      githubProjectStatus: 'GitHub Project Status',
      githubProjectPriority: 'GitHub Project Priority',
      githubProjectRoadmap: 'GitHub Project Roadmap',
      githubProjectRequestType: 'GitHub Project Request Type',
      githubProjectTargetDate: 'GitHub Project Target Date',
      githubProjectOwner: 'GitHub Project Owner',
      githubProjectSource: 'GitHub Project Source',
      githubProjectItemId: 'GitHub Project Item ID',
      githubMilestone: 'GitHub Milestone',
      githubClosedAt: 'GitHub Closed At',
      lastGitHubSync: 'Last GitHub Sync',
      lastGitHubProjectSync: 'Last GitHub Project Sync',
      syncStatus: 'Sync Status',
      syncError: 'Sync Error',
      lastSyncDirection: 'Last Sync Direction',
      lastSyncActor: 'Last Sync Actor',
      lastCommentHash: 'Last Comment Hash',
      lastProcessedAt: 'Last Processed At',
    },
    defaultLabels: ['intake', 'from:notion'],
    allowedPriorityLabels: ['priority: high'],
    includeRequesterEmail: true,
  };
}

function projectConfig() {
  return {
    ...config(),
    projectSyncEnabled: true,
    githubProjectId: 'PVT_project',
    githubProjectFields: {
      status: 'Status',
      priority: 'Priority',
      roadmap: 'Roadmap',
      requestType: 'Request Type',
      targetDate: 'Target Date',
      owner: 'Owner',
      source: 'Source',
    },
    githubProjectDefaults: {
      status: 'Inbox',
      source: 'Notion',
    },
  };
}

test('syncOnce creates one GitHub issue for a new Notion row', async () => {
  const updates = [];
  const created = [];
  const notion = {
    listRows: async () => [{
      id: 'page-1',
      url: 'https://notion/page-1',
      values: {
        Title: 'New bug',
        Description: 'Broken',
      },
    }],
    updateRow: async (id, values) => updates.push({ id, values }),
  };
  const github = {
    findIssueByNotionPageId: async () => null,
    createIssue: async (issue) => {
      created.push(issue);
      return {
        html_url: 'https://github.com/o/r/issues/1',
        number: 1,
        node_id: 'node-1',
        state: 'open',
        labels: [{ name: 'intake' }],
        assignees: [],
      };
    },
  };

  const result = await syncOnce({ config: config(), notion, github, now: () => '2026-05-18T00:00:00.000Z' });

  assert.equal(result.createdIssues, 1);
  assert.equal(created.length, 1);
  assert.equal(updates[0].values['GitHub Issue Number'], 1);
  assert.equal(updates[0].values['Sync Status'], 'synced');
  assert.equal(updates[0].values['Last Sync Direction'], 'notion_to_github');
});

test('syncOnce links an existing GitHub issue instead of creating a duplicate', async () => {
  const updates = [];
  const notion = {
    listRows: async () => [{
      id: 'page-1',
      url: 'https://notion/page-1',
      values: {
        Title: 'New bug',
        Description: 'Broken',
      },
    }],
    updateRow: async (id, values) => updates.push({ id, values }),
  };
  const github = {
    findIssueByNotionPageId: async () => ({
      html_url: 'https://github.com/o/r/issues/9',
      number: 9,
      node_id: 'node-9',
      state: 'open',
      labels: [],
      assignees: [],
    }),
    createIssue: async () => {
      throw new Error('should not create duplicate');
    },
  };

  const result = await syncOnce({ config: config(), notion, github, now: () => '2026-05-18T00:00:00.000Z' });

  assert.equal(result.createdIssues, 0);
  assert.equal(result.linkedExistingIssues, 1);
  assert.equal(updates[0].values['GitHub Issue Number'], 9);
});

test('syncOnce posts a follow-up comment exactly once', async () => {
  const comments = [];
  const updates = [];
  const row = {
    id: 'page-1',
    url: 'https://notion/page-1',
    values: {
      Title: 'Existing',
      'GitHub Issue Number': 3,
      'GitHub Issue URL': 'https://github.com/o/r/issues/3',
      'Requester Follow-up': 'Any update?',
      'Send Follow-up': true,
      'Last Comment Hash': '',
    },
  };
  const notion = {
    listRows: async () => [row],
    updateRow: async (id, values) => updates.push({ id, values }),
  };
  const github = {
    addComment: async (number, body) => {
      comments.push({ number, body });
      return { html_url: 'https://github.com/o/r/issues/3#comment' };
    },
    getIssue: async () => ({
      html_url: 'https://github.com/o/r/issues/3',
      number: 3,
      node_id: 'node-3',
      state: 'open',
      labels: [],
      assignees: [],
    }),
  };

  const result = await syncOnce({ config: config(), notion, github, now: () => '2026-05-18T00:00:00.000Z' });

  assert.equal(result.commentsPosted, 1);
  assert.equal(comments[0].body, 'Requester follow-up from Notion:\n\nAny update?');
  assert.equal(updates[0].values['Send Follow-up'], false);
  assert.ok(updates[0].values['Last Comment Hash']);
});

test('syncOnce does not repost an already-synced follow-up', async () => {
  const comment = 'Requester follow-up from Notion:\n\nAny update?';
  const updates = [];
  const notion = {
    listRows: async () => [{
      id: 'page-1',
      values: {
        'GitHub Issue Number': 3,
        'GitHub Issue URL': 'https://github.com/o/r/issues/3',
        'Requester Follow-up': 'Any update?',
        'Send Follow-up': true,
        'Last Comment Hash': stableHash(comment),
      },
    }],
    updateRow: async (id, values) => updates.push({ id, values }),
  };
  const github = {
    addComment: async () => {
      throw new Error('should not repost comment');
    },
    getIssue: async () => ({
      html_url: 'https://github.com/o/r/issues/3',
      number: 3,
      node_id: 'node-3',
      state: 'open',
      labels: [],
      assignees: [],
    }),
  };

  const result = await syncOnce({ config: config(), notion, github });

  assert.equal(result.commentsPosted, 0);
  assert.equal(updates[0].values['Send Follow-up'], false);
});

test('syncOnce records visible Notion sync errors for invalid rows', async () => {
  const updates = [];
  const notion = {
    listRows: async () => [{
      id: 'page-1',
      url: 'https://notion/page-1',
      values: {
        Title: 'Missing description',
      },
    }],
    updateRow: async (id, values) => updates.push({ id, values }),
  };
  const github = {
    findIssueByNotionPageId: async () => null,
    createIssue: async () => {
      throw new Error('should not reach GitHub');
    },
  };

  const result = await syncOnce({ config: config(), notion, github, now: () => '2026-05-18T00:00:00.000Z' });

  assert.equal(result.errors, 1);
  assert.equal(updates[0].values['Sync Status'], 'error');
  assert.match(updates[0].values['Sync Error'], /Missing required Notion fields: Description/);
});

test('syncOnce mirrors GitHub Project fields into Notion when configured', async () => {
  const updates = [];
  const ensured = [];
  const notion = {
    listRows: async () => [{
      id: 'page-1',
      values: {
        'GitHub Issue Number': 3,
        'GitHub Issue URL': 'https://github.com/o/r/issues/3',
      },
    }],
    updateRow: async (id, values) => updates.push({ id, values }),
  };
  const github = {
    getIssue: async () => ({
      html_url: 'https://github.com/o/r/issues/3',
      number: 3,
      node_id: 'ISSUE_node',
      state: 'open',
      labels: [],
      assignees: [],
    }),
    ensureProjectItem: async (issueNodeId) => {
      ensured.push(issueNodeId);
      return { id: 'PVTI_item', fields: {} };
    },
    getProjectItemForIssue: async () => ({
      id: 'PVTI_item',
      fields: {
        Status: 'In Progress',
        Priority: 'High',
        Roadmap: 'Q3',
        'Request Type': 'Feature',
        'Target Date': '2026-08-01',
        Owner: 'lee',
        Source: 'Notion',
      },
    }),
  };

  const result = await syncOnce({
    config: projectConfig(),
    notion,
    github,
    now: () => '2026-05-18T00:00:00.000Z',
  });

  assert.deepEqual(ensured, ['ISSUE_node']);
  assert.equal(result.ensuredProjectItems, 1);
  assert.equal(result.mirroredProjectItems, 1);
  assert.equal(updates[0].values['GitHub Project Item ID'], 'PVTI_item');
  assert.equal(updates[0].values['GitHub Project Status'], 'In Progress');
  assert.equal(updates[0].values['GitHub Project Priority'], 'High');
  assert.equal(updates[0].values['GitHub Project Roadmap'], 'Q3');
  assert.equal(updates[0].values['GitHub Project Request Type'], 'Feature');
  assert.equal(updates[0].values['GitHub Project Target Date'], '2026-08-01');
  assert.equal(updates[0].values['GitHub Project Owner'], 'lee');
  assert.equal(updates[0].values['GitHub Project Source'], 'Notion');
});

test('syncOnce initializes Project metadata for newly created Notion intake issues', async () => {
  const initialized = [];
  const notion = {
    listRows: async () => [{
      id: 'page-1',
      url: 'https://notion/page-1',
      values: {
        Title: 'Add roadmap page',
        'Request Type': 'Feature Request',
        Description: 'Please add a roadmap page',
        'Business Priority': 'priority: high',
      },
    }],
    updateRow: async () => {},
  };
  const github = {
    findIssueByNotionPageId: async () => null,
    createIssue: async () => ({
      html_url: 'https://github.com/o/r/issues/12',
      number: 12,
      node_id: 'ISSUE_node',
      state: 'open',
      labels: [],
      assignees: [],
    }),
    ensureProjectItem: async () => ({ id: 'PVTI_item', fields: {} }),
    setProjectItemFields: async (itemId, fields) => initialized.push({ itemId, fields }),
    getProjectItemForIssue: async () => ({
      id: 'PVTI_item',
      fields: {
        Status: 'Inbox',
        Priority: 'High',
        'Request Type': 'Feature Request',
        Source: 'Notion',
      },
    }),
  };

  const result = await syncOnce({
    config: projectConfig(),
    notion,
    github,
    now: () => '2026-05-18T00:00:00.000Z',
  });

  assert.equal(result.createdIssues, 1);
  assert.deepEqual(initialized, [{
    itemId: 'PVTI_item',
    fields: {
      Status: 'Inbox',
      Source: 'Notion',
      'Request Type': 'Feature Request',
      Priority: 'High',
    },
  }]);
});