feat(bypass): prompt to confirm if admins should be able to bypass required checks for user repo

Author: travi

src/prompt/constants.js

@@ -1,3 +1,8 @@
 export const ids = {REQUIRED_CHECK_BYPASS: 'REQUIRED_CHECK_BYPASS'};
 
-export const questionNames = {[ids.REQUIRED_CHECK_BYPASS]: {CHECK_BYPASS_TEAM: 'CHECK_BYPASS_TEAM'}};
+export const questionNames = {
+  [ids.REQUIRED_CHECK_BYPASS]: {
+    CHECK_BYPASS_TEAM: 'CHECK_BYPASS_TEAM',
+    ADMIN_BYPASS: 'ADMIN_BYPASS'
+  }
+};

src/rulesets/verification/bypass-actors/prompt.js

@@ -2,9 +2,31 @@ import {ids, questionNames} from '../../../prompt/constants.js';
 
 export const ADMIN_ROLE_ID = 5;
 
+async function defineQuestionToChooseBypassTeam(checkBypassTeamQuestionName, vcs, octokit) {
+  const {data: teams} = await octokit.request('GET /orgs/{org}/teams', {org: vcs.owner});
+
+  return {
+    type: 'list',
+    name: checkBypassTeamQuestionName,
+    message: 'Which team should be able to bypass the required checks?',
+    choices: teams.map(({name, slug, id}) => ({name, value: id, short: slug}))
+  };
+}
+
+async function defineQuestionToConfirmAdminBypass(adminBypassQuestionName) {
+  return {
+    type: 'confirm',
+    name: adminBypassQuestionName,
+    message: 'Should repository admins be able to bypass the required checks?'
+  };
+}
+
 export default async function promptForCheckBypass(vcs, {prompt, octokit}) {
   const promptId = ids.REQUIRED_CHECK_BYPASS;
-  const checkBypassTeamQuestionName = questionNames[promptId].CHECK_BYPASS_TEAM;
+  const {
+    [questionNames[promptId].CHECK_BYPASS_TEAM]: checkBypassTeamQuestionName,
+    [questionNames[promptId].ADMIN_BYPASS]: adminBypassQuestionName
+  } = questionNames[promptId];
 
   if (!octokit) {
     const missingOctokitError = new Error('No octokit instance provided');
@@ -15,23 +37,20 @@ export default async function promptForCheckBypass(vcs, {prompt, octokit}) {
 
   const {data: {login: authenticatedUser}} = await octokit.request('GET /user');
 
-  if (vcs.owner === authenticatedUser) {
-    return {role: ADMIN_ROLE_ID};
-  }
-
-  const {data: teams} = await octokit.request('GET /orgs/{org}/teams', {org: vcs.owner});
-
-  const {[checkBypassTeamQuestionName]: teamId} = await prompt({
+  const {
+    [checkBypassTeamQuestionName]: teamId,
+    [adminBypassQuestionName]: adminBypass
+  } = await prompt({
     id: promptId,
     questions: [
-      {
-        type: 'list',
-        name: checkBypassTeamQuestionName,
-        message: 'Which team should be able to bypass the required checks?',
-        choices: teams.map(({name, slug, id}) => ({name, value: id, short: slug}))
-      }
+      vcs.owner === authenticatedUser
+        ? await defineQuestionToConfirmAdminBypass(adminBypassQuestionName)
+        : await defineQuestionToChooseBypassTeam(checkBypassTeamQuestionName, vcs, octokit)
     ]
   });
 
-  return {team: teamId};
+  return {
+    team: teamId,
+    role: adminBypass && ADMIN_ROLE_ID
+  };
 }

src/rulesets/verification/bypass-actors/prompt.test.js

@@ -7,7 +7,10 @@ import promptForCheckBypass, {ADMIN_ROLE_ID} from './prompt.js';
 
 describe('required check bypass prompt', () => {
   const promptId = ids.REQUIRED_CHECK_BYPASS;
-  const checkBypassTeamQuestionName = questionNames[promptId].CHECK_BYPASS_TEAM;
+  const {
+    CHECK_BYPASS_TEAM: checkBypassTeamQuestionName,
+    ADMIN_BYPASS: adminBypassQuestionName
+  } = questionNames[promptId];
   const teamId = any.word();
 
   it('should enable choosing a team to bypass the required check for an organization owned repository', async () => {
@@ -22,14 +25,12 @@ describe('required check bypass prompt', () => {
     when(prompt)
       .calledWith({
         id: promptId,
-        questions: [
-          {
-            type: 'list',
-            name: checkBypassTeamQuestionName,
-            message: 'Which team should be able to bypass the required checks?',
-            choices
-          }
-        ]
+        questions: [{
+          type: 'list',
+          name: checkBypassTeamQuestionName,
+          message: 'Which team should be able to bypass the required checks?',
+          choices
+        }]
       })
       .thenResolve({[checkBypassTeamQuestionName]: teamId});
 
@@ -42,6 +43,16 @@ describe('required check bypass prompt', () => {
     const user = any.word();
     const vcs = {...any.simpleObject(), owner: user};
     when(octokit.request).calledWith('GET /user').thenResolve({data: {login: user}});
+    when(prompt)
+      .calledWith({
+        id: promptId,
+        questions: [{
+          type: 'confirm',
+          name: adminBypassQuestionName,
+          message: 'Should repository admins be able to bypass the required checks?'
+        }]
+      })
+      .thenResolve({[adminBypassQuestionName]: true});
 
     expect(await promptForCheckBypass(vcs, {prompt, octokit})).toEqual({role: ADMIN_ROLE_ID});
   });

test/integration/features/step_definitions/common-steps.js

@@ -7,6 +7,7 @@ import any from '@travi/any';
 
 // eslint-disable-next-line import/no-extraneous-dependencies,import/no-unresolved
 import {lift, promptConstants, scaffold, test} from '@form8ion/repository-settings';
+import {questionNames} from '../../../../src/prompt/constants.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));          // eslint-disable-line no-underscore-dangle
 const stubbedNodeModules = stubbedFs.load(resolve(__dirname, '..', '..', '..', '..', 'node_modules'));
@@ -68,16 +69,26 @@ When('scaffolder results are processed', async function () {
         octokit: this.octokit,
         prompt: ({id, questions}) => {
           let chosenTeamId;
-          const checkBypassTeamQuestionName = promptConstants.questionNames[id].CHECK_BYPASS_TEAM;
+          const {
+            [promptConstants.questionNames[id].CHECK_BYPASS_TEAM]: checkBypassTeamQuestionName,
+            [promptConstants.questionNames[id].ADMIN_BYPASS]: adminBypassQuestionName
+          } = questionNames[id];
 
-          if (this.octokit) {
-            const {choices: checkBypassTeamChoices} = questions.find(({name}) => name === checkBypassTeamQuestionName);
+          const checkBypassTeamQuestion = questions.find(({name}) => name === checkBypassTeamQuestionName);
+          const adminBypassQuestion = questions.find(({name}) => name === adminBypassQuestionName);
+
+          if (checkBypassTeamQuestion) {
+            const {choices: checkBypassTeamChoices} = checkBypassTeamQuestion;
             ({value: chosenTeamId} = checkBypassTeamChoices.find(team => team.name === this.maintenanceTeamName));
-          } else {
-            chosenTeamId = this.maintenanceTeamName;
+
+            return {[checkBypassTeamQuestionName]: chosenTeamId};
+          }
+
+          if (adminBypassQuestion) {
+            return {[adminBypassQuestionName]: true};
           }
 
-          return {[checkBypassTeamQuestionName]: chosenTeamId};
+          throw new Error('Expected a question to be asked for the required check bypass');
         }
       }
     );