Add integration tests for checkLegalBoilerplate orchestration function

Extract checkLegalBoilerplate() from dangerfile.js into dangerfile-utils.js
with dependency injection (accepts { danger, fail, markdown } as parameters)
so the orchestration logic can be tested without the DangerJS runtime.

Adds 19 tests covering author association filtering, template discovery,
missing/mismatched boilerplate detection, success cases, and markdown output.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: vaind

danger/dangerfile-utils.js

@@ -120,9 +120,117 @@ function extractLegalBoilerplateSection(templateContent) {
   return legalSection.join('\n').trim();
 }
 
+/**
+ * Check that external contributors include the required legal boilerplate in their PR body.
+ * Accepts danger context and reporting functions as parameters for testability.
+ *
+ * @param {object} options
+ * @param {object} options.danger - The DangerJS danger object
+ * @param {Function} options.fail - DangerJS fail function
+ * @param {Function} options.markdown - DangerJS markdown function
+ */
+async function checkLegalBoilerplate({ danger, fail, markdown }) {
+  console.log('::debug:: Checking legal boilerplate requirements...');
+
+  // Check if the PR author is an external contributor using author_association
+  const authorAssociation = danger.github.pr.author_association;
+  const isExternalContributor = !['OWNER', 'MEMBER', 'COLLABORATOR'].includes(authorAssociation);
+
+  if (!isExternalContributor) {
+    console.log('::debug:: Skipping legal boilerplate check for organization member/collaborator');
+    return;
+  }
+
+  // Find PR template
+  let prTemplateContent = null;
+  const possibleTemplatePaths = [
+    '.github/PULL_REQUEST_TEMPLATE.md',
+    '.github/pull_request_template.md',
+    'PULL_REQUEST_TEMPLATE.md',
+    'pull_request_template.md',
+    '.github/PULL_REQUEST_TEMPLATE/pull_request_template.md'
+  ];
+
+  for (const templatePath of possibleTemplatePaths) {
+    const content = await danger.github.utils.fileContents(templatePath);
+    if (content) {
+      prTemplateContent = content;
+      console.log(`::debug:: Found PR template at ${templatePath}`);
+      break;
+    }
+  }
+
+  if (!prTemplateContent) {
+    console.log('::debug:: No PR template found, skipping legal boilerplate check');
+    return;
+  }
+
+  // Check if template contains a Legal Boilerplate section
+  const legalBoilerplateHeaderRegex = /^#{1,6}\s+Legal\s+Boilerplate/im;
+  if (!legalBoilerplateHeaderRegex.test(prTemplateContent)) {
+    console.log('::debug:: PR template does not contain a Legal Boilerplate section');
+    return;
+  }
+
+  // Extract expected boilerplate from template
+  const expectedBoilerplate = extractLegalBoilerplateSection(prTemplateContent);
+  const prBody = danger.github.pr.body || '';
+
+  // Extract actual boilerplate from PR body
+  const actualBoilerplate = extractLegalBoilerplateSection(prBody);
+
+  // Check if PR body contains the legal boilerplate section
+  if (!actualBoilerplate) {
+    fail('This PR is missing the required legal boilerplate. As an external contributor, please include the "Legal Boilerplate" section from the PR template in your PR description.');
+
+    markdown(`
+### ⚖️ Legal Boilerplate Required
+
+As an external contributor, your PR must include the legal boilerplate from the PR template.
+
+Please add the following section to your PR description:
+
+\`\`\`markdown
+${expectedBoilerplate}
+\`\`\`
+
+This is required to ensure proper intellectual property rights for your contributions.
+    `.trim());
+    return;
+  }
+
+  // Verify the actual boilerplate matches the expected one
+  // Normalize whitespace for comparison
+  const normalizeWhitespace = (str) => str.replace(/\s+/g, ' ').trim();
+  const expectedNormalized = normalizeWhitespace(expectedBoilerplate);
+  const actualNormalized = normalizeWhitespace(actualBoilerplate);
+
+  if (expectedNormalized !== actualNormalized) {
+    fail('The legal boilerplate in your PR description does not match the template. Please ensure you include the complete, unmodified legal text from the PR template.');
+
+    markdown(`
+### ⚖️ Legal Boilerplate Mismatch
+
+Your PR contains a "Legal Boilerplate" section, but it doesn't match the required text from the template.
+
+Please replace it with the exact text from the template:
+
+\`\`\`markdown
+${expectedBoilerplate}
+\`\`\`
+
+This is required to ensure proper intellectual property rights for your contributions.
+    `.trim());
+    return;
+  }
+
+  console.log('::debug:: Legal boilerplate validated successfully ✓');
+}
+
 module.exports = {
   FLAVOR_CONFIG,
   getFlavorConfig,
   extractPRFlavor,
-  extractLegalBoilerplateSection
+  extractLegalBoilerplateSection,
+  checkLegalBoilerplate
 };

danger/dangerfile-utils.test.js

@@ -1,6 +1,6 @@
 const { describe, it } = require('node:test');
 const assert = require('node:assert');
-const { getFlavorConfig, extractPRFlavor, extractLegalBoilerplateSection, FLAVOR_CONFIG } = require('./dangerfile-utils.js');
+const { getFlavorConfig, extractPRFlavor, extractLegalBoilerplateSection, checkLegalBoilerplate, FLAVOR_CONFIG } = require('./dangerfile-utils.js');
 
 describe('dangerfile-utils', () => {
   describe('getFlavorConfig', () => {
@@ -521,4 +521,247 @@ Second paragraph with blank lines above.
       assert.ok(blankLineCount >= 1, 'Should preserve blank lines');
     });
   });
+});
+
+// --- Integration tests for checkLegalBoilerplate ---
+
+const PR_TEMPLATE_WITH_BOILERPLATE = `# Pull Request Template
+
+## Description
+Please describe your changes
+
+### Legal Boilerplate
+Look, I get it. The entity doing business as "Sentry" was incorporated in the State of Delaware in 2015 as Functional Software, Inc. and is gonna need some rights from me in order to utilize my contributions in this here PR. So here's the deal: I retain all rights, title and interest in and to my contributions, and by keeping this boilerplate intact I confirm that Sentry can use, modify, copy, and redistribute my contributions, under Sentry's choice of terms.
+
+## Checklist
+- [ ] Tests added`;
+
+const LEGAL_TEXT = 'Look, I get it. The entity doing business as "Sentry" was incorporated in the State of Delaware in 2015 as Functional Software, Inc. and is gonna need some rights from me in order to utilize my contributions in this here PR. So here\'s the deal: I retain all rights, title and interest in and to my contributions, and by keeping this boilerplate intact I confirm that Sentry can use, modify, copy, and redistribute my contributions, under Sentry\'s choice of terms.';
+
+/**
+ * Build a mock danger context for checkLegalBoilerplate tests.
+ * @param {object} overrides - Properties to override on danger.github.pr
+ * @param {string|null} templateContent - Content returned by fileContents for template paths (null = no template)
+ */
+function buildMockContext({ prOverrides = {}, templateContent = PR_TEMPLATE_WITH_BOILERPLATE } = {}) {
+  const failMessages = [];
+  const markdownMessages = [];
+
+  const danger = {
+    github: {
+      pr: {
+        author_association: 'CONTRIBUTOR',
+        body: '',
+        ...prOverrides
+      },
+      utils: {
+        fileContents: async (path) => {
+          // Only return content for the first standard template path
+          if (templateContent && path === '.github/PULL_REQUEST_TEMPLATE.md') {
+            return templateContent;
+          }
+          return '';
+        }
+      }
+    }
+  };
+
+  return {
+    danger,
+    fail: (msg) => failMessages.push(msg),
+    markdown: (msg) => markdownMessages.push(msg),
+    failMessages,
+    markdownMessages
+  };
+}
+
+describe('checkLegalBoilerplate', () => {
+  // --- Skips for internal contributors ---
+
+  it('should skip check for OWNER association', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'OWNER' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0);
+    assert.strictEqual(ctx.markdownMessages.length, 0);
+  });
+
+  it('should skip check for MEMBER association', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'MEMBER' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0);
+  });
+
+  it('should skip check for COLLABORATOR association', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'COLLABORATOR' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0);
+  });
+
+  // --- External contributor associations that should be checked ---
+
+  it('should check for CONTRIBUTOR association', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'CONTRIBUTOR', body: '' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1, 'Should fail for external CONTRIBUTOR without boilerplate');
+  });
+
+  it('should check for FIRST_TIME_CONTRIBUTOR association', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'FIRST_TIME_CONTRIBUTOR', body: '' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1);
+  });
+
+  it('should check for NONE association', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'NONE', body: '' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1);
+  });
+
+  // --- Template discovery ---
+
+  it('should skip when no PR template is found', async () => {
+    const ctx = buildMockContext({ templateContent: null });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0, 'Should not fail when no template exists');
+  });
+
+  it('should skip when template has no Legal Boilerplate section', async () => {
+    const ctx = buildMockContext({ templateContent: '# Template\n\n## Description\nJust a normal template.' });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0, 'Should not fail when template lacks legal section');
+  });
+
+  it('should find template at the first matching path', async () => {
+    const calledPaths = [];
+    const ctx = buildMockContext();
+    ctx.danger.github.utils.fileContents = async (path) => {
+      calledPaths.push(path);
+      // Return content for the second path to verify it tries multiple
+      if (path === '.github/pull_request_template.md') {
+        return PR_TEMPLATE_WITH_BOILERPLATE;
+      }
+      return '';
+    };
+    ctx.danger.github.pr.body = `## My PR\n\n### Legal Boilerplate\n${LEGAL_TEXT}`;
+    await checkLegalBoilerplate(ctx);
+    assert.ok(calledPaths.includes('.github/PULL_REQUEST_TEMPLATE.md'), 'Should try uppercase path first');
+    assert.ok(calledPaths.includes('.github/pull_request_template.md'), 'Should try lowercase path second');
+    // Should stop after finding the template (not try remaining paths)
+    assert.ok(!calledPaths.includes('PULL_REQUEST_TEMPLATE.md'), 'Should stop after finding template');
+  });
+
+  // --- Missing boilerplate in PR body ---
+
+  it('should fail when external contributor PR body is empty', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'NONE', body: '' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1);
+    assert.ok(ctx.failMessages[0].includes('missing the required legal boilerplate'));
+    assert.strictEqual(ctx.markdownMessages.length, 1);
+    assert.ok(ctx.markdownMessages[0].includes('Legal Boilerplate Required'));
+  });
+
+  it('should fail when external contributor PR body is null', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'CONTRIBUTOR', body: null } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1);
+    assert.ok(ctx.failMessages[0].includes('missing the required legal boilerplate'));
+  });
+
+  it('should fail when PR body has no legal section', async () => {
+    const ctx = buildMockContext({
+      prOverrides: {
+        author_association: 'FIRST_TIME_CONTRIBUTOR',
+        body: '## Description\nMy cool changes\n\n## Checklist\n- [x] Tests'
+      }
+    });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1);
+    assert.ok(ctx.failMessages[0].includes('missing the required legal boilerplate'));
+  });
+
+  // --- Boilerplate mismatch ---
+
+  it('should fail when boilerplate text is modified', async () => {
+    const ctx = buildMockContext({
+      prOverrides: {
+        author_association: 'CONTRIBUTOR',
+        body: '### Legal Boilerplate\nI changed the legal text to something else entirely.'
+      }
+    });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1);
+    assert.ok(ctx.failMessages[0].includes('does not match the template'));
+    assert.strictEqual(ctx.markdownMessages.length, 1);
+    assert.ok(ctx.markdownMessages[0].includes('Legal Boilerplate Mismatch'));
+  });
+
+  it('should fail when boilerplate is truncated', async () => {
+    const ctx = buildMockContext({
+      prOverrides: {
+        author_association: 'CONTRIBUTOR',
+        body: '### Legal Boilerplate\nLook, I get it. The entity doing business as "Sentry" was incorporated in the State of Delaware in 2015.'
+      }
+    });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 1);
+    assert.ok(ctx.failMessages[0].includes('does not match the template'));
+  });
+
+  // --- Matching boilerplate (success cases) ---
+
+  it('should pass when boilerplate matches exactly', async () => {
+    const ctx = buildMockContext({
+      prOverrides: {
+        author_association: 'CONTRIBUTOR',
+        body: `## Description\nMy changes\n\n### Legal Boilerplate\n${LEGAL_TEXT}\n\n## Checklist\n- [x] Done`
+      }
+    });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0, 'Should not fail when boilerplate matches');
+    assert.strictEqual(ctx.markdownMessages.length, 0);
+  });
+
+  it('should pass when boilerplate matches with different whitespace', async () => {
+    const ctx = buildMockContext({
+      prOverrides: {
+        author_association: 'CONTRIBUTOR',
+        body: `### Legal Boilerplate\n${LEGAL_TEXT.replace(/\. /g, '.\n')}`
+      }
+    });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0, 'Should pass with normalized whitespace differences');
+  });
+
+  it('should pass when boilerplate has extra surrounding whitespace', async () => {
+    const ctx = buildMockContext({
+      prOverrides: {
+        author_association: 'CONTRIBUTOR',
+        body: `### Legal Boilerplate\n\n  ${LEGAL_TEXT}  \n\n## Next`
+      }
+    });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.failMessages.length, 0);
+  });
+
+  // --- Markdown message content ---
+
+  it('should include expected boilerplate in the markdown hint when missing', async () => {
+    const ctx = buildMockContext({ prOverrides: { author_association: 'NONE', body: '' } });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.markdownMessages.length, 1);
+    assert.ok(ctx.markdownMessages[0].includes('Functional Software, Inc.'), 'Markdown should include the expected legal text');
+  });
+
+  it('should include expected boilerplate in the markdown hint on mismatch', async () => {
+    const ctx = buildMockContext({
+      prOverrides: {
+        author_association: 'CONTRIBUTOR',
+        body: '### Legal Boilerplate\nWrong text here.'
+      }
+    });
+    await checkLegalBoilerplate(ctx);
+    assert.strictEqual(ctx.markdownMessages.length, 1);
+    assert.ok(ctx.markdownMessages[0].includes('Functional Software, Inc.'));
+  });
 });