@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/gitlab/resources.js

@@ -1,4 +1,4 @@
-import { mapGitLabCI, mapGitLabDiff, mapGitLabIssue, mapGitLabMergeRequest, mapGitLabNote, mapGitLabProject } from './mappers.js';
+import { mapGitLabCI, mapGitLabCommit, mapGitLabDiff, mapGitLabIssue, mapGitLabMergeRequest, mapGitLabNote, mapGitLabProject, mapGitLabUser, mapGitLabVerdictNote } from './mappers.js';
 import { resolveGitLabProjectsFromDirectory } from './repo.js';
 import { isPlainObject, isString } from './validation.js';
 
@@ -14,6 +14,11 @@ const PER_PAGE = 20;
 // end within this bound; past it the read fails instead of passing a capped
 // list off as complete.
 const COLLECTION_PER_PAGE = 100;
+// List filters: the picker's names to GitLab's.
+const LIST_STATES = { open: 'opened', closed: 'closed', merged: 'merged', all: 'all' };
+const LIST_SCOPES = { any: 'all', assigned: 'assigned_to_me', created: 'created_by_me' };
+// The preview's timeline shows the newest commits only.
+const TIMELINE_COMMIT_LIMIT = 50;
 const COLLECTION_MAX_PAGES = 20;
 
 function requireMapped(value, message) {
@@ -197,9 +202,30 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
   };
   const constrainedProject = async (...args) => (await constrainedProjectNetwork(...args)).target;
 
+  // The account's own user, read once: review requests are filtered by name.
+  let currentUsername = null;
+  const readCurrentUsername = async () => {
+    currentUsername ??= client.Users.showCurrentUser().then((user) => {
+      if (!isPlainObject(user) || !isString(user.username) || !user.username.trim()) throw new Error('GitLab returned an invalid current user');
+      return user.username;
+    });
+    return currentUsername;
+  };
+
+  /** A list's state and whose items, as GitLab's list parameters. */
+  const listFilter = async (options, kind) => {
+    const state = LIST_STATES[options.state] ?? 'opened';
+    const people = options.people ?? 'any';
+    if (people === 'reviewRequested') {
+      return kind === 'pull' ? { state, scope: 'all', reviewerUsername: await readCurrentUsername() } : { state, scope: 'all' };
+    }
+    return { state: kind === 'issue' && state === 'merged' ? 'closed' : state, scope: LIST_SCOPES[people] ?? 'all' };
+  };
+
   const listProjectMRs = (projectId, options) => client.MergeRequests.all({
     projectId,
-    scope: 'all',
+    scope: options.scope ?? 'all',
+    reviewerUsername: options.reviewerUsername,
     maxPages: 1,
     perPage: options.perPage ?? 100,
     page: options.page ?? 1,
@@ -391,6 +417,36 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
     };
   };
 
+  const postNote = async (create) => {
+    const raw = await create();
+    if (!isPlainObject(raw) || !Number.isInteger(raw.id)) throw new Error('GitLab returned an invalid note');
+  };
+
+  // Requesting changes exists only in GitLab's GraphQL API. The path is
+  // resolved against the REST base (/api/v4/), so it reaches /api/graphql
+  // through the same credential and no-redirect requester.
+  const REQUEST_CHANGES_MUTATION = `mutation($path: ID!, $iid: String!) {
+  mergeRequestRequestChanges(input: { projectPath: $path, iid: $iid }) {
+    mergeRequest { iid }
+    errors
+  }
+}`;
+  const requestChanges = async (project, number) => {
+    const response = await client.MergeRequests.requester.post('../graphql', {
+      body: { query: REQUEST_CHANGES_MUTATION, variables: { path: `${project.owner}/${project.name}`, iid: String(number) } },
+    });
+    const payload = response?.body;
+    const result = payload?.data?.mergeRequestRequestChanges;
+    const errors = [
+      ...(Array.isArray(payload?.errors) ? payload.errors.map((error) => error?.message) : []),
+      ...(Array.isArray(result?.errors) ? result.errors : []),
+    ].filter((message) => isString(message) && message.trim());
+    // GraphQL answers a refusal (not a reviewer, an older GitLab) with 200
+    // and errors: nothing was changed.
+    if (errors.length) throw Object.assign(new Error(errors.join('; ')), { status: 422 });
+    if (!isPlainObject(result?.mergeRequest)) throw new Error('GitLab returned an invalid request-changes result');
+  };
+
   const resolveMutationActionTarget = async (payload) => {
     if (payload.providerTarget) {
       return {
@@ -432,6 +488,149 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
 
     resolveChangeRequestMutation: readMutationRequest,
 
+    async resolveIssueMutation(context, expected) {
+      if (expected.head !== undefined || expected.base !== undefined || expected.headSha !== undefined) {
+        throw Object.assign(new Error('GitLab issue target is invalid'), { code: 'INVALID_SOURCE_CONTROL_MUTATION_CONTEXT', status: 400 });
+      }
+      const target = await constrainedProject(context.directory, expected.project, context.primaryRemote);
+      const issue = requireIssue(await client.Issues.show(expected.number, { projectId: target.project.id }), target.project);
+      if (issue.number !== expected.number) throw new Error('GitLab returned an invalid issue');
+      return {
+        providerTarget: { projectId: target.project.id, number: issue.number },
+        target: resolvedMutationTarget(context, target.project, { number: issue.number }),
+      };
+    },
+
+    /** Close or reopen; GitLab refuses to reopen a merged merge request. */
+    async setChangeRequestState(payload) {
+      const { projectId, number } = payload.providerTarget;
+      const raw = await client.MergeRequests.edit(projectId, number, { stateEvent: payload.state === 'closed' ? 'close' : 'reopen' });
+      const request = requireMutationResponse(raw, payload.targetProject, payload.providerTarget, payload.expectedTarget);
+      if (request.state !== payload.state) throw new Error('GitLab returned an unexpected merge request state');
+      return { state: request.state };
+    },
+
+    async setIssueState(payload) {
+      const { projectId, number } = payload.providerTarget;
+      const raw = await client.Issues.edit(projectId, number, { stateEvent: payload.state === 'closed' ? 'close' : 'reopen' });
+      const issue = requireIssue(raw, payload.targetProject);
+      if (issue.number !== number || issue.state !== payload.state) throw new Error('GitLab returned an unexpected issue state');
+      return { state: issue.state };
+    },
+
+    /** One page of the project's labels, for the board's picker. */
+    async listLabels(directory, selector, remote) {
+      const target = await constrainedProject(directory, selector, remote);
+      const raw = await client.ProjectLabels.all(target.project.id, { perPage: 100, maxPages: 1 });
+      if (!Array.isArray(raw)) throw new Error('GitLab returned an invalid label list');
+      return raw.flatMap((label) => {
+        if (!isPlainObject(label) || !isString(label.name) || !label.name) return [];
+        return [isString(label.color) && label.color ? { name: label.name, color: label.color.replace(/^#/, '') } : { name: label.name }];
+      });
+    },
+
+    /** One page of the project's active members, inherited ones too: who can be asked to review. */
+    async listReviewerCandidates(directory, selector, remote) {
+      const target = await constrainedProject(directory, selector, remote);
+      const raw = await client.ProjectMembers.all(target.project.id, { includeInherited: true, perPage: 100, maxPages: 1 });
+      if (!Array.isArray(raw)) throw new Error('GitLab returned an invalid member list');
+      return raw.flatMap((member) => {
+        const user = member?.state === 'active' ? mapGitLabUser(member, identity) : null;
+        if (!user) return [];
+        return [user.avatarUrl ? { id: user.id, login: user.username, avatarUrl: user.avatarUrl } : { id: user.id, login: user.username }];
+      });
+    },
+
+    /** The whole label set; an empty one clears them. */
+    async setLabels(payload) {
+      const { projectId, number } = payload.providerTarget;
+      const update = { labels: payload.labels.join(',') };
+      const raw = payload.kind === 'issue-labels'
+        ? await client.Issues.edit(projectId, number, update)
+        : await client.MergeRequests.edit(projectId, number, update);
+      if (!isPlainObject(raw) || raw.iid !== number) throw new Error('GitLab returned an invalid edit result');
+      return {};
+    },
+
+    /** The whole reviewer set, by user id; an empty one removes them all. */
+    async setReviewers(payload) {
+      const { projectId, number } = payload.providerTarget;
+      const raw = await client.MergeRequests.edit(projectId, number, { reviewerIds: payload.reviewers.map(Number) });
+      requireMutationResponse(raw, payload.targetProject, payload.providerTarget, payload.expectedTarget);
+      return {};
+    },
+
+    /** Only a match is certain: another edit since may have moved the set either way. */
+    async reconcileSetMutation(providerTarget, kind, names) {
+      const { projectId, number } = providerTarget;
+      const raw = kind === 'issue-labels'
+        ? await client.Issues.show(number, { projectId })
+        : await client.MergeRequests.show(projectId, number);
+      const current = kind === 'change-request-reviewers'
+        ? (Array.isArray(raw?.reviewers) ? raw.reviewers.map((user) => String(user?.id)) : null)
+        : (Array.isArray(raw?.labels) ? raw.labels.map((label) => (isString(label) ? label : label?.name)) : null);
+      if (!current || current.length !== names.length || !current.every((entry) => names.includes(entry))) return { state: 'outcome-unknown' };
+      return { state: 'succeeded', result: {} };
+    },
+
+    async reconcileStateMutation(providerTarget, kind, state) {
+      const { projectId, number } = providerTarget;
+      const project = (await showProject(projectId)).project;
+      const current = kind === 'issue-state'
+        ? requireIssue(await client.Issues.show(number, { projectId }), project).state
+        : requireMutationMergeRequest(await client.MergeRequests.show(projectId, number), project).state;
+      if (current === state) return { state: 'succeeded', result: { state } };
+      if (current === 'open' || current === 'closed') {
+        return { state: 'failed', result: { failureStatus: 409, failureCode: 'SOURCE_CONTROL_MUTATION_NOT_APPLIED' } };
+      }
+      return { state: 'outcome-unknown' };
+    },
+
+    commentChangeRequest(payload) {
+      const { projectId, number } = payload.providerTarget;
+      return postNote(() => client.MergeRequestNotes.create(projectId, number, payload.body));
+    },
+
+    commentIssue(payload) {
+      const { projectId, number } = payload.providerTarget;
+      return postNote(() => client.IssueNotes.create(projectId, number, payload.body));
+    },
+
+    /**
+     * The verdict first, then its text as a note: GitLab has no review that
+     * carries both. A verdict that lands with a note that does not is still
+     * a verdict, reported as `commented: false` so the text is not lost.
+     */
+    async reviewChangeRequest(payload) {
+      const { projectId, number } = payload.providerTarget;
+      if (payload.verdict === 'approve') {
+        try {
+          // The approval is for the commit the user read.
+          await client.MergeRequestApprovals.approve(projectId, number, { sha: payload.expectedTarget.headSha });
+        } catch (error) {
+          const status = requestStatus(error);
+          if (status === 409) {
+            throw Object.assign(new Error('GitLab merge request headSha changed'), {
+              code: 'SOURCE_CONTROL_MUTATION_TARGET_MISMATCH', status: 409,
+            });
+          }
+          // GitLab answers an approval it does not allow (your own merge
+          // request, one already approved) with 401; the account is fine.
+          if (status === 401) throw Object.assign(new Error('GitLab did not allow this approval'), { status: 403 });
+          throw error;
+        }
+      } else {
+        await requestChanges(payload.targetProject, number);
+      }
+      if (payload.body === undefined) return { commented: false };
+      try {
+        await postNote(() => client.MergeRequestNotes.create(projectId, number, payload.body));
+        return { commented: true };
+      } catch {
+        return { commented: false };
+      }
+    },
+
     async reconcileCreateMutation(providerTarget, target) {
       const payload = readMergeRequestList(await listProjectMRs(providerTarget.targetProjectId, {
         state: 'all', sourceBranch: target.head, perPage: 100,
@@ -598,7 +797,7 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
       const targets = await expandTargets([resolved.projects[0]], { requireComplete: canonicalReads });
       const target = targets.at(-1);
       const page = readPage(await listProjectMRs(target.project.id, {
-        state: 'opened', page: options.page ?? 1, perPage: PER_PAGE, search: options.query, showExpanded: true,
+        ...await listFilter(options, 'pull'), page: options.page ?? 1, perPage: PER_PAGE, search: options.query, showExpanded: true,
       }));
       const rawItems = readMergeRequestList(page.items, target.project);
       const items = rawItems.map((raw) => canonicalReads
@@ -612,7 +811,7 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
         constrainToPrimary: options.constrainToPrimary,
         remote: options.remote,
       });
-      const [notes, diffs, ci, headProject] = await Promise.all([
+      const [notes, diffs, ci, headProject, commitPage] = await Promise.all([
         readCollection((page) => client.MergeRequestNotes.all(target.project.id, number, page), 'GitLab merge request has more notes than OpenChamber reads'),
         options.includeDiff
           ? readCollection((page) => client.MergeRequests.allDiffs(target.project.id, number, page), 'GitLab merge request has more changed files than OpenChamber reads')
@@ -622,6 +821,11 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
         Number.isInteger(raw?.source_project_id) && raw.source_project_id !== target.raw?.id
           ? showProject(raw.source_project_id).then((item) => item.project)
           : Promise.resolve(null),
+        // The newest commits, newest first as GitLab lists them; only the
+        // preview's timeline asks.
+        options.includeTimeline
+          ? client.MergeRequests.allCommits(target.project.id, number, { maxPages: 1, perPage: TIMELINE_COMMIT_LIMIT, showExpanded: true }).then(readPage)
+          : Promise.resolve(null),
       ]);
       if (canonicalReads && !Array.isArray(notes)) throw new Error('GitLab returned an invalid merge request note list');
       if (canonicalReads && !Array.isArray(diffs)) throw new Error('GitLab returned an invalid merge request diff list');
@@ -652,7 +856,7 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
         ? requireMergeRequest(raw, target.project)
         : requireMapped(mapGitLabMergeRequest(raw, identity, target.project), 'GitLab returned an invalid merge request');
       if (headProject) changeRequest.headProject = headProject;
-      return {
+      const context = {
         identity,
         project: target.project,
         changeRequest,
@@ -662,13 +866,33 @@ export function createGitLabResourceService({ origin, client, resolveProjects =
         diff: files.map((file) => file.patch).filter(Boolean).join('\n'),
         ci,
       };
+      if (!options.includeTimeline) return context;
+      if (canonicalReads && !Array.isArray(commitPage?.items)) throw new Error('GitLab returned an invalid merge request commit list');
+      return {
+        ...context,
+        commits: asArray(commitPage?.items).flatMap((commit) => {
+          const mapped = mapGitLabCommit(commit);
+          return mapped ? [mapped] : [];
+        }).reverse(),
+        // More than one page means the list above is only the newest ones.
+        commitsComplete: !commitPage?.hasMore,
+        // Who is asked to review, for the preview's reviewer picker.
+        reviewers: asArray(raw.reviewers).flatMap((user) => {
+          const mapped = mapGitLabUser(user, identity);
+          return mapped ? [mapped] : [];
+        }),
+        verdicts: asArray(notes).flatMap((note) => {
+          const mapped = mapGitLabVerdictNote(note, identity, raw.web_url);
+          return mapped ? [mapped] : [];
+        }),
+      };
     },
 
     async listIssues(directory, options = {}) {
       const resolved = await resolveDirectoryProjects(directory, options.remote);
       const target = resolved.projects[0];
       const page = readPage(await client.Issues.all({
-        projectId: target.project.id, scope: 'all', state: 'opened', page: options.page ?? 1,
+        projectId: target.project.id, ...await listFilter(options, 'issue'), page: options.page ?? 1,
         perPage: PER_PAGE, maxPages: 1, search: options.query, showExpanded: true,
       }));
       if (canonicalReads && !Array.isArray(page.items)) throw new Error('GitLab returned an invalid issue list');

package/server/lib/gitlab/resources.test.js

@@ -86,6 +86,52 @@ describe('GitLab resource service', () => {
     await expect(result).rejects.toThrow('invalid merge request');
   });
 
+  it('lists by state and by whose items, reading the user once for review requests', async () => {
+    const all = list([openMR]);
+    const showCurrentUser = vi.fn(async () => ({ id: 3, username: 'sam' }));
+    const issuesAll = list([]);
+    const { service } = setup({
+      MergeRequests: { ...setup().client.MergeRequests, all },
+      Users: { showCurrentUser },
+      Issues: { ...setup().client.Issues, all: issuesAll },
+    });
+    await service.listChangeRequests('/repo', { state: 'merged', people: 'created' });
+    expect(all.mock.calls.at(-1)?.[0]).toMatchObject({ state: 'merged', scope: 'created_by_me' });
+    await service.listChangeRequests('/repo', { state: 'all', people: 'reviewRequested' });
+    await service.listChangeRequests('/repo', { people: 'reviewRequested' });
+    expect(all.mock.calls.at(-1)?.[0]).toMatchObject({ state: 'opened', scope: 'all', reviewerUsername: 'sam' });
+    expect(showCurrentUser).toHaveBeenCalledTimes(1);
+    await service.listIssues('/repo', { state: 'merged', people: 'assigned' });
+    expect(issuesAll.mock.calls.at(-1)?.[0]).toMatchObject({ state: 'closed', scope: 'assigned_to_me' });
+  });
+
+  it('adds commits and review verdicts only when the timeline asks', async () => {
+    const commits = [
+      { id: 'bbb', title: 'second', author_name: 'Sam', committed_date: '2026-10-02T10:00:00Z', web_url: `${origin}/team/repo/-/commit/bbb` },
+      { id: 'aaa', title: 'first', author_name: 'Sam', committed_date: '2026-10-01T10:00:00Z', web_url: `${origin}/team/repo/-/commit/aaa` },
+    ];
+    const notes = [
+      { id: 4, body: 'Looks good', author: { id: 3, username: 'sam' } },
+      { id: 5, body: 'approved this merge request', system: true, created_at: '2026-10-02T11:00:00Z', author: { id: 3, username: 'sam' } },
+      { id: 6, body: 'added 1 commit', system: true, author: { id: 3, username: 'sam' } },
+    ];
+    const allCommits = list(commits);
+    const { service } = setup({
+      MergeRequests: { ...setup().client.MergeRequests, allCommits, show: vi.fn(async () => ({ ...openMR, reviewers: [{ id: 7, username: 'ann' }, { username: 'no-id' }] })) },
+      MergeRequestNotes: { all: list(notes) },
+    });
+    const plain = await service.changeRequestContext('/repo', 5, {});
+    expect(plain).not.toHaveProperty('commits');
+    expect(allCommits).not.toHaveBeenCalled();
+
+    const result = await service.changeRequestContext('/repo', 5, { includeTimeline: true });
+    expect(result.commits.map((commit) => commit.headline)).toEqual(['first', 'second']);
+    expect(result.commitsComplete).toBe(true);
+    expect(result.verdicts).toMatchObject([{ state: 'approved', createdAt: '2026-10-02T11:00:00Z', author: { username: 'sam' } }]);
+    expect(result.issueComments.map((comment) => comment.body)).toEqual(['Looks good']);
+    expect(result.reviewers).toEqual([expect.objectContaining({ id: '7', username: 'ann' })]);
+  });
+
   it('keeps merge-request context when CI jobs fail', async () => {
     const { service } = setup({ Jobs: { all: vi.fn(async () => { throw new Error('jobs unavailable'); }) } });
     const result = await service.changeRequestContext('/repo', 5, { includeDiff: true, includeCIDetails: true });
@@ -545,6 +591,139 @@ describe('GitLab resource service', () => {
   });
 });
 
+describe('GitLab comments and reviews', () => {
+  const review = (overrides = {}) => ({
+    providerTarget: { projectId: '2', number: 5 },
+    targetProject: { id: '2', owner: 'team', name: 'repo' },
+    expectedTarget: { project: { id: '2', owner: 'team', name: 'repo' }, number: 5, headSha: 'abc' },
+    verdict: 'approve',
+    ...overrides,
+  });
+  const notes = (create) => ({ MergeRequestNotes: { ...setup().client.MergeRequestNotes, create } });
+
+  it('approves the commit the user read, then posts the text as a note', async () => {
+    const approve = vi.fn(async () => ({}));
+    const create = vi.fn(async () => ({ id: 7 }));
+    const { service } = setup({ MergeRequestApprovals: { approve }, ...notes(create) });
+
+    await expect(service.reviewChangeRequest(review({ body: 'Nice' }))).resolves.toEqual({ commented: true });
+    await expect(service.reviewChangeRequest(review())).resolves.toEqual({ commented: false });
+
+    expect(approve).toHaveBeenCalledWith('2', 5, { sha: 'abc' });
+    expect(create).toHaveBeenCalledOnce();
+    expect(create).toHaveBeenCalledWith('2', 5, 'Nice');
+  });
+
+  it('keeps the verdict when its note fails and says the text did not post', async () => {
+    const create = vi.fn(async () => { throw Object.assign(new Error('locked'), { cause: { response: { status: 403 } } }); });
+    const { service } = setup({ MergeRequestApprovals: { approve: vi.fn(async () => ({})) }, ...notes(create) });
+
+    await expect(service.reviewChangeRequest(review({ body: 'Nice' }))).resolves.toEqual({ commented: false });
+  });
+
+  it('turns an approval GitLab does not allow into a refusal, not a lost sign-in', async () => {
+    const refused = Object.assign(new Error('401 Unauthorized'), { cause: { response: { status: 401 } } });
+    const moved = Object.assign(new Error('SHA does not match'), { cause: { response: { status: 409 } } });
+    const own = setup({ MergeRequestApprovals: { approve: vi.fn(async () => { throw refused; }) } });
+    const late = setup({ MergeRequestApprovals: { approve: vi.fn(async () => { throw moved; }) } });
+
+    await expect(own.service.reviewChangeRequest(review())).rejects.toMatchObject({ status: 403 });
+    await expect(late.service.reviewChangeRequest(review())).rejects.toMatchObject({ code: 'SOURCE_CONTROL_MUTATION_TARGET_MISMATCH', status: 409 });
+  });
+
+  it('requests changes through GraphQL and reports its errors as a refusal', async () => {
+    const post = vi.fn(async () => ({ body: { data: { mergeRequestRequestChanges: { mergeRequest: { iid: '5' }, errors: [] } } } }));
+    const { service } = setup({ MergeRequests: { ...setup().client.MergeRequests, requester: { post } } });
+
+    await expect(service.reviewChangeRequest(review({ verdict: 'request-changes' }))).resolves.toEqual({ commented: false });
+    expect(post).toHaveBeenCalledWith('../graphql', {
+      body: { query: expect.stringContaining('mergeRequestRequestChanges'), variables: { path: 'team/repo', iid: '5' } },
+    });
+
+    post.mockResolvedValueOnce({ body: { data: { mergeRequestRequestChanges: { mergeRequest: null, errors: ['Reviewer not found'] } } } });
+    await expect(service.reviewChangeRequest(review({ verdict: 'request-changes' }))).rejects.toMatchObject({ message: 'Reviewer not found', status: 422 });
+    post.mockResolvedValueOnce({ body: { data: null, errors: [{ message: "Field 'mergeRequestRequestChanges' doesn't exist" }] } });
+    await expect(service.reviewChangeRequest(review({ verdict: 'request-changes' }))).rejects.toMatchObject({ status: 422 });
+  });
+
+  it('reads labels and active members, and sets labels and reviewers as whole sets', async () => {
+    const editMR = vi.fn(async (_id, _iid, update) => ({ ...openMR, labels: update.labels?.split(',') ?? [] }));
+    const editIssue = vi.fn(async () => ({ iid: 3, title: 'Bug', web_url: `${origin}/me/repo/-/issues/3`, state: 'opened' }));
+    const { service } = setup({
+      MergeRequests: { ...setup().client.MergeRequests, edit: editMR, show: vi.fn(async () => ({ ...openMR, labels: ['bug'], reviewers: [{ id: 7, username: 'ann' }] })) },
+      Issues: { ...setup().client.Issues, edit: editIssue },
+      ProjectLabels: { all: vi.fn(async () => [{ name: 'bug', color: '#d73a4a' }, { name: '' }]) },
+      ProjectMembers: { all: vi.fn(async () => [
+        { id: 7, username: 'ann', avatar_url: `${origin}/a.png`, state: 'active' },
+        { id: 8, username: 'gone', state: 'blocked' },
+      ]) },
+    });
+    const project = { id: '2', owner: 'team', name: 'repo' };
+
+    await expect(service.listLabels('/repo', { owner: 'team', name: 'repo' })).resolves.toEqual([{ name: 'bug', color: 'd73a4a' }]);
+    await expect(service.listReviewerCandidates('/repo', { owner: 'team', name: 'repo' }))
+      .resolves.toEqual([{ id: '7', login: 'ann', avatarUrl: `${origin}/a.png` }]);
+
+    await service.setLabels({ kind: 'change-request-labels', labels: ['bug', 'docs'], providerTarget: { projectId: '2', number: 5 } });
+    await service.setLabels({ kind: 'issue-labels', labels: [], providerTarget: { projectId: '1', number: 3 } });
+    await service.setReviewers({
+      reviewers: ['7'], providerTarget: { projectId: '2', number: 5 }, targetProject: project, expectedTarget: { project, number: 5 },
+    });
+    expect(editMR).toHaveBeenNthCalledWith(1, '2', 5, { labels: 'bug,docs' });
+    expect(editIssue).toHaveBeenCalledWith('1', 3, { labels: '' });
+    expect(editMR).toHaveBeenNthCalledWith(2, '2', 5, { reviewerIds: [7] });
+
+    await expect(service.reconcileSetMutation({ projectId: '2', number: 5 }, 'change-request-labels', ['bug'])).resolves.toMatchObject({ state: 'succeeded' });
+    await expect(service.reconcileSetMutation({ projectId: '2', number: 5 }, 'change-request-reviewers', ['7'])).resolves.toMatchObject({ state: 'succeeded' });
+    await expect(service.reconcileSetMutation({ projectId: '2', number: 5 }, 'change-request-labels', ['docs'])).resolves.toEqual({ state: 'outcome-unknown' });
+  });
+
+  it('closes and reopens through stateEvent and reconciles from the current state', async () => {
+    const editMR = vi.fn(async () => ({ ...openMR, state: 'closed' }));
+    const editIssue = vi.fn(async () => ({ iid: 3, title: 'Bug', web_url: `${origin}/me/repo/-/issues/3`, state: 'opened' }));
+    const { service } = setup({
+      MergeRequests: { ...setup().client.MergeRequests, edit: editMR },
+      Issues: { ...setup().client.Issues, edit: editIssue },
+    });
+    const project = { id: '2', owner: 'team', name: 'repo' };
+
+    await expect(service.setChangeRequestState({
+      state: 'closed', providerTarget: { projectId: '2', number: 5 }, targetProject: project, expectedTarget: { project, number: 5 },
+    })).resolves.toEqual({ state: 'closed' });
+    await expect(service.setIssueState({
+      state: 'open', providerTarget: { projectId: '1', number: 3 }, targetProject: { id: '1', owner: 'me', name: 'repo' },
+    })).resolves.toEqual({ state: 'open' });
+    expect(editMR).toHaveBeenCalledWith('2', 5, { stateEvent: 'close' });
+    expect(editIssue).toHaveBeenCalledWith('1', 3, { stateEvent: 'reopen' });
+
+    await expect(service.reconcileStateMutation({ projectId: '2', number: 5 }, 'change-request-state', 'open'))
+      .resolves.toEqual({ state: 'succeeded', result: { state: 'open' } });
+    await expect(service.reconcileStateMutation({ projectId: '1', number: 3 }, 'issue-state', 'closed'))
+      .resolves.toMatchObject({ state: 'failed' });
+  });
+
+  it('comments on merge requests and on issues in the bound project', async () => {
+    const mrNote = vi.fn(async () => ({ id: 8 }));
+    const issueNote = vi.fn(async () => ({ id: 9 }));
+    const { service, client } = setup({ ...notes(mrNote), IssueNotes: { ...setup().client.IssueNotes, create: issueNote } });
+    const context = { directory: '/repo', repositoryId: 'repo_one', bindingRevision: 3, primaryRemote: 'origin' };
+
+    const resolved = await service.resolveIssueMutation(context, { project: { owner: 'me', name: 'repo' }, number: 3 });
+    await service.commentIssue({ providerTarget: resolved.providerTarget, body: 'On it' });
+    await service.commentChangeRequest({ providerTarget: { projectId: '2', number: 5 }, body: 'Looks good' });
+
+    expect(resolved).toEqual({
+      providerTarget: { projectId: '1', number: 3 },
+      target: { repositoryId: 'repo_one', bindingRevision: 3, primaryRemote: 'origin', project: { id: '1', owner: 'me', name: 'repo' }, number: 3 },
+    });
+    expect(client.Issues.show).toHaveBeenCalledWith(3, { projectId: '1' });
+    expect(issueNote).toHaveBeenCalledWith('1', 3, 'On it');
+    expect(mrNote).toHaveBeenCalledWith('2', 5, 'Looks good');
+    await expect(service.resolveIssueMutation(context, { project: { owner: 'me', name: 'repo' }, number: 3, headSha: 'abc' }))
+      .rejects.toMatchObject({ code: 'INVALID_SOURCE_CONTROL_MUTATION_CONTEXT' });
+  });
+});
+
 describe('GitLab merge request comparison reads', () => {
   const diffRefs = { base_sha: 'a'.repeat(40), head_sha: 'b'.repeat(40), start_sha: 'c'.repeat(40) };