From f8adcf9795573912b2cf6adef3345c3a328e4718 Mon Sep 17 00:00:00 2001 From: Jake Bolam Date: Thu, 6 Oct 2022 15:02:01 -0400 Subject: [PATCH] feat: support adding multiple users in a single message (#127) Co-authored-by: Angel Aviel Domaoan <13580338+tenshiAMD@users.noreply.github.com> --- package-lock.json | 12 +- .../probot-processIssueComment.js | 252 +++++++++++++++++ .../utils/parse-comment/index.js | 254 +++++++++++++++++ .../__snapshots__/issue_comment.test.js.snap | 12 +- .../utils/parse-comment/index.test.js | 258 ++++++++++++++++++ 5 files changed, 776 insertions(+), 12 deletions(-) create mode 100644 src/tasks/processIssueComment/probot-processIssueComment.js create mode 100644 src/tasks/processIssueComment/utils/parse-comment/index.js create mode 100644 test/tasks/processIssueComment/utils/parse-comment/index.test.js diff --git a/package-lock.json b/package-lock.json index e1d176ac..1225ef93 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2045,9 +2045,9 @@ } }, "node_modules/all-contributors-cli": { - "version": "6.23.0", - "resolved": "https://registry.npmjs.org/all-contributors-cli/-/all-contributors-cli-6.23.0.tgz", - "integrity": "sha512-myfnxTFLJ1hL5wA705QYkLm08iney2J+A1DC3m2fAe+oyFoXH03u2oK+G7B/cvgrbVl5eWw8yELKmtR6iAtoCw==", + "version": "6.23.1", + "resolved": "https://registry.npmjs.org/all-contributors-cli/-/all-contributors-cli-6.23.1.tgz", + "integrity": "sha512-k5qS+l7booUL3e/R/8mxliUd4SqP5hmLq7LDcm4uCoQe1sGlSPebVNQEmvEuWbAxUOTPFJZX2pC0U/UNGCUNAA==", "dependencies": { "@babel/runtime": "^7.7.6", "async": "^3.1.0", @@ -10829,9 +10829,9 @@ } }, "all-contributors-cli": { - "version": "6.23.0", - "resolved": "https://registry.npmjs.org/all-contributors-cli/-/all-contributors-cli-6.23.0.tgz", - "integrity": "sha512-myfnxTFLJ1hL5wA705QYkLm08iney2J+A1DC3m2fAe+oyFoXH03u2oK+G7B/cvgrbVl5eWw8yELKmtR6iAtoCw==", + "version": "6.23.1", + "resolved": "https://registry.npmjs.org/all-contributors-cli/-/all-contributors-cli-6.23.1.tgz", + "integrity": "sha512-k5qS+l7booUL3e/R/8mxliUd4SqP5hmLq7LDcm4uCoQe1sGlSPebVNQEmvEuWbAxUOTPFJZX2pC0U/UNGCUNAA==", "requires": { "@babel/runtime": "^7.7.6", "async": "^3.1.0", diff --git a/src/tasks/processIssueComment/probot-processIssueComment.js b/src/tasks/processIssueComment/probot-processIssueComment.js new file mode 100644 index 00000000..96183149 --- /dev/null +++ b/src/tasks/processIssueComment/probot-processIssueComment.js @@ -0,0 +1,252 @@ +const Analytics = require('../../utils/Analytics') +const CommentReply = require('./CommentReply') +const Repository = require('./Repository') +const OptionsConfig = require('./OptionsConfig') +const ContentFiles = require('./ContentFiles') + +const getUserDetails = require('./utils/getUserDetails') +const parseComment = require('./utils/parse-comment') + +const { + AllContributorBotError, + BranchNotFoundError, + ResourceNotFoundError, +} = require('./utils/errors') + +const getSafeRef = require('./utils/git/getSafeRef') + +async function processAddContributors({ + context, + commentReply, + repository, + optionsConfig, + contributors, + branchName, +}) { + + const usersAdded = [] + const usersMissed = [] + + async function addContributor(who, contributions) { + if (contributions.length === 0) { + context.log.debug(`No contributions for ${who}`) + usersMissed.push(who) + return + } + + // TODO: wrap this blog in a try catch, if one user fails, don't fail the whole pull request + const { name, avatar_url, profile } = await getUserDetails({ + github: context.github, + username: who, + }) + + await optionsConfig.addContributor({ + login: who, + contributions, + name, + avatar_url, + profile, + }) + + usersAdded.push(who) + } + + // TODO: throttle max paralle requests + const addContributorPromises = contributors.map(function(contributor) { + return addContributor((contributor.who, contributor.contributions)) + }) + + await Promise.all(addContributorPromises) + + if (usersAdded === 0) { + return commentReply.reply( + `I couldn't determine any contributions for ${usersAdded.join(', ')}. + Did you specify any contributions? Please make sure to use [valid contribution names](https://allcontributors.org/docs/en/emoji-key).`, + ) + + const contentFiles = new ContentFiles({ + repository, + }) + await contentFiles.fetch(optionsConfig) + if (optionsConfig.getOriginalSha() === undefined) { + contentFiles.init() + } + contentFiles.generate(optionsConfig) + const filesByPathToUpdate = contentFiles.get() + filesByPathToUpdate[optionsConfig.getPath()] = { + content: optionsConfig.getRaw(), + originalSha: optionsConfig.getOriginalSha(), + } + + const pullRequestBodyAdds = `Adds the following contributors: +- ${usersAdded.join('\n- ')}\n\n` + + const pullRequestBodyMissed = `Unable to determine contributions for the following contributors, these were excluded from this PR: +- ${usersMissed.join('\\n- ')}\n\n` + + const pullRequestBodyRequester = `This was requested by ${commentReply.replyingToWho()} [in this comment](${commentReply.replyingToWhere()})` + + const { + pullRequestURL, + pullCreated, + } = await repository.createPullRequestFromFiles({ + title: `docs: add new contributors`, + body: `${pullRequestBodyAdds}.\n\n +${usersMissed > 0 ? pullRequestBodyMissed : ''} +${pullRequestBodyRequester} +`, + filesByPath: filesByPathToUpdate, + branchName, + }) + + if (pullCreated) { + commentReply.reply( + `I've put up [a pull request](${pullRequestURL}) to add new contributors! :tada:`, + ) + return + } + // Updated + commentReply.reply( + `I've updated [the pull request](${pullRequestURL}) to add contributors! :tada:`, + ) +} + +async function setupRepository({ context, branchName }) { + const defaultBranch = context.payload.repository.default_branch + const repository = new Repository({ + ...context.repo(), + github: context.github, + defaultBranch, + log: context.log, + }) + + try { + await repository.getRef(branchName) + context.log.info( + `Branch: ${branchName} EXISTS, will work from this branch`, + ) + repository.setBaseBranch(branchName) + } catch (error) { + if (error instanceof BranchNotFoundError) { + context.log.info( + `Branch: ${branchName} DOES NOT EXIST, will work from default branch`, + ) + } else { + throw error + } + } + + return repository +} + +async function setupOptionsConfig({ repository }) { + const optionsConfig = new OptionsConfig({ + repository, + }) + + try { + await optionsConfig.fetch() + } catch (error) { + if (error instanceof ResourceNotFoundError) { + optionsConfig.init() + } else { + throw error + } + } + + return optionsConfig +} + +async function probotProcessIssueComment({ context, commentReply, analytics }) { + const commentBody = context.payload.comment.body + analytics.track('processComment', { + commentBody: commentBody, + }) + const { action, contributors } = parseComment(commentBody) + + if (action === 'add') { + analytics.track('addContributors', { + who: commentBody, + contributors, + }) + + const whos = contributors.map(({ who }) => who).join('--') + const safeWho = getSafeRef(whos) + // TODO: max length on branch name? + // TODO: should this be the branch name + const branchName = `all-contributors/add-${safeWho}` + + const repository = await setupRepository({ + context, + branchName, + }) + const optionsConfig = await setupOptionsConfig({ repository }) + + await processAddContributors({ + context, + commentReply, + repository, + optionsConfig, + contributors, + branchName, + }) + analytics.track('processCommentSuccess') + return + } + + analytics.track('unknownIntent', { + action, + }) + + commentReply.reply(`I could not determine your intention.`) + commentReply.reply( + `Basic usage: @all-contributors please add @jakebolam for code, doc and infra`, + ) + commentReply.reply( + `For other usages see the [documentation](https://allcontributors.org/docs/en/bot/usage)`, + ) + return +} + +async function probotProcessIssueCommentSafe({ context }) { + const analytics = new Analytics({ + ...context.repo(), + user: context.payload.sender.login, + log: context.log, + }) + const commentReply = new CommentReply({ context }) + try { + await probotProcessIssueComment({ context, commentReply, analytics }) + } catch (error) { + if (error instanceof AllContributorBotError) { + context.log.info(error) + commentReply.reply(error.message) + analytics.track('errorKnown', { + errorMessage: error.message, + }) + } else { + context.log.error(error) + commentReply.reply( + `We had trouble processing your request. Please try again later.`, + ) + analytics.track('errorUnKnown', { + errorMessage: error.message, + }) + throw error + } + } finally { + await commentReply.send() + await analytics.finishQueue() + } +} + +function processIssueCommentApp(app) { + // issueComment.edited + // Issue comments and PR comments both create issue_comment events + app.on('issue_comment.created', async context => { + app.log.trace(context) + await probotProcessIssueCommentSafe({ context }) + }) +} + +module.exports = processIssueCommentApp diff --git a/src/tasks/processIssueComment/utils/parse-comment/index.js b/src/tasks/processIssueComment/utils/parse-comment/index.js new file mode 100644 index 00000000..d86b5f65 --- /dev/null +++ b/src/tasks/processIssueComment/utils/parse-comment/index.js @@ -0,0 +1,254 @@ +const nlp = require('compromise') + +// Types that are valid (multi words must all be lower case) +const validContributionTypes = [ + 'blog', + 'bug', + 'business', + 'code', + 'content', + 'design', + 'doc', + 'eventorganizing', + 'example', + 'financial', + 'fundingfinding', + 'ideas', + 'infra', + 'maintenance', + 'platform', + 'plugin', + 'projectManagement', + 'question', + 'review', + 'security', + 'talk', + 'test', + 'tool', + 'translation', + 'tutorial', + 'usertesting', + 'video', +] + +// Types that are valid multi words, that we need to re map back to there camelCase parts +const validMultiContributionTypesMapping = { + eventorganizing: 'eventOrganizing', + fundingfinding: 'fundingFinding', + usertesting: 'userTesting', + projectmanagement: 'projectManagement', +} + +// Additional terms to match to types (plurals, aliases etc) +const contributionTypeMappings = { + blogs: 'blog', + blogging: 'blog', + bugs: 'bug', + codes: 'code', + coding: 'code', + designing: 'design', + desigs: 'design', + doc: 'doc', + docs: 'doc', + documenting: 'doc', + documentation: 'doc', + examples: 'example', + finance: 'financial', + financials: 'financial', + funds: 'fundingfinding', + idea: 'ideas', + infras: 'infra', + infrastructure: 'infra', + maintaining: 'maintenance', + management: 'projectManagement', + managing: 'projectManagement', + platforms: 'platform', + plugins: 'plugin', + project: 'projectManagement', + projectManaging: 'projectManagement', + questions: 'question', + reviews: 'review', + securing: 'security', + talks: 'talk', + tests: 'test', + testing: 'test', + tools: 'tool', + tooling: 'tool', + translator: 'translation', + translating: 'translation', + translations: 'translation', + tutorials: 'tutorial', + videoes: 'video', +} + +// Additional terms to match to types (plurals, aliases etc) that are multi word +const contributionTypeMultiWordMapping = { + 'event organizing': 'eventOrganizing', + 'fund finding': 'fundingFinding', + 'funding finding': 'fundingFinding', + 'user testing': 'userTesting', + 'business development': 'business', + 'project management': 'projectManagement', +} + +const Contributions = {} + +validContributionTypes.forEach(type => { + Contributions[type] = 'Contribution' +}) + +Object.keys(contributionTypeMappings).forEach(type => { + Contributions[`${type}`] = 'Contribution' +}) + +const plugin = { + words: { + ...Contributions, + add: 'Action', + }, +} + +nlp.plugin(plugin) + +function findWho(message, action) { + function findWhoSafe(match) { + message = message.replace('-', '#/#') // workaround (https://github.com/spencermountain/compromise/issues/726) + const whoNormalizeSettings = { + whitespace: true, // remove hyphens, newlines, and force one space between words + case: false, // keep only first-word, and 'entity' titlecasing + numbers: false, // turn 'seven' to '7' + punctuation: true, // remove commas, semicolons - but keep sentence-ending punctuation + unicode: false, // visually romanize/anglicize 'Björk' into 'Bjork'. + contractions: false, // turn "isn't" to "is not" + acronyms: false, //remove periods from acronyms, like 'F.B.I.' + parentheses: false, //remove words inside brackets (like these) + possessives: false, // turn "Google's tax return" to "Google tax return" + plurals: false, // turn "batmobiles" into "batmobile" + verbs: false, // turn all verbs into Infinitive form - "I walked" → "I walk" + honorifics: false, //turn 'Vice Admiral John Smith' to 'John Smith' + } + const matchedSet = nlp(message) + .match(match) + .normalize(whoNormalizeSettings) + .data() + + if (matchedSet.length > 0) { + matchedText = matchedSet[0].text + matchedText = matchedText.replace('#/#', '-') + + return matchedText + } + } + + const whoMatchedMention = findWhoSafe(`@[.]`) + // TODO: Unused + // if (whoMatchedMention) { + // return whoMatchedMention + // } + + const whoMatchedByAction = findWhoSafe(`${action} [.]`) + if (whoMatchedByAction) { + return whoMatchedByAction + } + + const whoMatchedByFor = findWhoSafe(`[.] for`) + if (whoMatchedByFor) { + return whoMatchedByFor + } +} + +function parseAddSentence(message, action) { + message = message.split(',').map(e => e.trim()).join(', ') + + const whoMatched = findWho(message, action) + if (!whoMatched) { + return { + who: undefined, + } + } + + const who = whoMatched.startsWith('@') ? whoMatched.substr(1) : whoMatched + + // Contributions + const doc = nlp(message).toLowerCase() + // This is to support multi word 'matches' (altho the compromise docs say it supports this *confused*) + Object.entries(contributionTypeMultiWordMapping).forEach( + ([multiWordType, singleWordType]) => { + doc.replace(multiWordType, singleWordType) + }, + ) + + const rawContributions = doc + .match('#Contribution') + .data() + .map(data => { + // This removes whitespace, commas etc + return data.normal + }) + + const contributions = + doc + .match('#Contribution') + .data() + .map(data => { + // This removes whitespace, commas etc + return data.normal + }).filter((element, index) => { + return rawContributions.indexOf(element) === index; + }).map(type => { + if (contributionTypeMappings[type]) + return contributionTypeMappings[type] + return type + }) + .map(type => { + // Convert usertesting to userTesting for the node api + if (validMultiContributionTypesMapping[type]) + return validMultiContributionTypesMapping[type] + return type + }) + + return { + who, + contributions, + } +} + +function parseAddComment(message, action) { + const contributors = {} + + const sentences = nlp(message).sentences() + sentences.forEach(function(sentence) { + const sentenceRaw = sentence.data()[0].text + const { who, contributions } = parseAddSentence(sentenceRaw, action) + + if (who) { + contributors[who] = contributions + } + }) + + return { + action: 'add', + contributors, + } +} + +function parseComment(message) { + const doc = nlp(message) + + const action = doc + .toLowerCase() + .match('#Action') + .normalize() + .out('string') + + // TODO: Check each sentennce + if (action.match('add')) { + return parseAddComment(message, action) + } + + return { + action: false, + } +} + +module.exports = parseComment diff --git a/test/integration/__snapshots__/issue_comment.test.js.snap b/test/integration/__snapshots__/issue_comment.test.js.snap index 1cf3bee7..23fe9c8d 100644 --- a/test/integration/__snapshots__/issue_comment.test.js.snap +++ b/test/integration/__snapshots__/issue_comment.test.js.snap @@ -421,7 +421,7 @@ Array [ exports[`issue_comment event Happy path, add correct new contributor, but branch exists and PR is open: request body 1`] = ` Object { "branch": "all-contributors/add-jakebolam", - "content": "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", + "content": "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", "message": "update README.md", "sha": "bfce087f5fbed22257de1ee5056b20de63da0a13", } @@ -490,7 +490,7 @@ Array [ exports[`issue_comment event Happy path, add correct new contributor, but branch exists: request body 1`] = ` Object { "branch": "all-contributors/add-jakebolam", - "content": "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", + "content": "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", "message": "update README.md", "sha": "bfce087f5fbed22257de1ee5056b20de63da0a13", } @@ -566,7 +566,7 @@ Object { exports[`issue_comment event Happy path, add correct new contributor, no allcontributors file (repo needs init first): request body 2`] = ` Object { "branch": "all-contributors/add-jakebolam", - "content": "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", + "content": "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", "message": "docs: update README.md [skip ci]", "sha": "bfce087f5fbed22257de1ee5056b20de63da0a13", } @@ -643,7 +643,7 @@ Object { exports[`issue_comment event Happy path, add correct new contributor: request body 2`] = ` Object { "branch": "all-contributors/add-jakebolam", - "content": "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", + "content": "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", "message": "update README.md", "sha": "bfce087f5fbed22257de1ee5056b20de63da0a13", } @@ -751,7 +751,7 @@ Object { exports[`issue_comment event User has no name and blog: request body 2`] = ` Object { "branch": "all-contributors/add-jakebolam", - "content": "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", + "content": "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", "message": "update README.md", "sha": "bfce087f5fbed22257de1ee5056b20de63da0a13", } @@ -848,7 +848,7 @@ Object { exports[`issue_comment event skipCi=false: request body 2`] = ` Object { "branch": "all-contributors/add-jakebolam", - "content": "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", + "content": "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", "message": "update README.md", "sha": "bfce087f5fbed22257de1ee5056b20de63da0a13", } diff --git a/test/tasks/processIssueComment/utils/parse-comment/index.test.js b/test/tasks/processIssueComment/utils/parse-comment/index.test.js new file mode 100644 index 00000000..142cb145 --- /dev/null +++ b/test/tasks/processIssueComment/utils/parse-comment/index.test.js @@ -0,0 +1,258 @@ +const parseComment = require('../../../../../src/tasks/processIssueComment/utils/parse-comment') + +describe('parseComment', () => { + const testBotName = 'all-contributors' + + test('Basic intent to add', () => { + expect( + parseComment( + `@${testBotName} please add jakebolam for doc, infra and code`, + ), + ).toEqual({ + action: 'add', + contributors: { + jakebolam: ['doc', 'infra', 'code'], + }, + }) + }) + + test('Basic intent to add - ignore case (for action and contributions, NOT for user)', () => { + expect( + parseComment( + `@${testBotName} please Add jakeBolam for DOC, inFra and coDe`, + ), + ).toEqual({ + action: 'add', + contributors: { + jakeBolam: ['doc', 'infra', 'code'], + }, + }) + }) + + test('Basic intent to add - non name username', () => { + expect( + parseComment(`@${testBotName} please add tbenning for design`), + ).toEqual({ + action: 'add', + contributors: { + tbenning: ['design'], + }, + }) + }) + + test('Basic intent to add - captialized username', () => { + expect( + parseComment(`@${testBotName} please add Rbot25_RULES for tool`), + ).toEqual({ + action: 'add', + contributors: { + Rbot25_RULES: ['tool'], + }, + }) + }) + + test('Basic intent to add - username with dash', () => { + expect( + parseComment(`@${testBotName} please add tenshi-AMD for tool`), + ).toEqual({ + action: 'add', + contributors: { + "tenshi-AMD": ['tool'], + }, + }) + }) + + test('Basic intent to add - with plurals', () => { + expect( + parseComment(`@${testBotName} please add dat2 for docs`), + ).toEqual({ + action: 'add', + contributors: { + dat2: ['doc'], + }, + }) + }) + + test('Add multiple when not spaced (just split via commas)', () => { + expect( + parseComment( + `@${testBotName} please add @stevoo24 for code,content`, + ), + ).toEqual({ + action: 'add', + contributors: { + stevoo24: ['code', 'content'], + }, + }) + }) + + test(`Interpret users who's names are contributions`, () => { + expect( + parseComment(`@${testBotName} please add @ideas for ideas`), + ).toEqual({ + action: 'add', + contributors: { + ideas: ['ideas'], + }, + }) + }) + + test('Support full words (like infrastructure)', () => { + expect( + parseComment( + `@${testBotName} please add jakebolam for infrastructure, documentation`, + ), + ).toEqual({ + action: 'add', + contributors: { + jakebolam: ['infra', 'doc'], + }, + }) + }) + + test('Support adding people with mentions', () => { + expect( + parseComment( + `@${testBotName} please add @sinchang for infrastructure`, + ), + ).toEqual({ + action: 'add', + contributors: { + sinchang: ['infra'], + }, + }) + }) + + test('Support alternative sentences', () => { + expect( + parseComment(`@${testBotName} add @sinchang for infrastructure`), + ).toEqual({ + action: 'add', + contributors: { + sinchang: ['infra'], + }, + }) + + expect( + parseComment( + `Jane you are crushing it in documentation and your infrastructure work has been great too, let's add jane.doe23 for her contributions. cc @${testBotName}`, + ), + ).toEqual({ + action: 'add', + contributors: { + 'jane.doe23': ['doc', 'infra'], + }, + }) + }) + + test('Support split words (like user testing)', () => { + expect( + parseComment( + `@${testBotName} please add jakebolam for infrastructure, fund finding`, + ), + ).toEqual({ + action: 'add', + contributors: { + jakebolam: ['infra', 'fundingFinding'], + }, + }) + + expect( + parseComment( + `@${testBotName} please add jakebolam for infrastructure, user testing and testing`, + ), + ).toEqual({ + action: 'add', + contributors: { + jakebolam: ['infra', 'userTesting', 'test'], + }, + }) + }) + + test('Support split words types that are referenced via other terms (e.g. a plural split word)', () => { + expect( + parseComment( + `@${testBotName} please add @jakebolam for infrastructure, funds`, + ), + ).toEqual({ + action: 'add', + contributors: { + jakebolam: ['infra', 'fundingFinding'], + }, + }) + }) + + // TODO: Looks like this is impossible to parse correctly, maybe we can change the format instead + // test('Add multiple users in 1 hit - for some contributions', () => { + // expect( + // parseComment( + // `@${testBotName} please add @jakebolam and @tbenning for doc and review`, + // ), + // ).toEqual({ + // action: 'add', + // contributors: { + // jakebolam: ['doc', 'review'], + // tbenning: ['doc', 'review'], + // }, + // }) + // }) + + test('Add multiple users in 1 hit - seperate sentences', () => { + expect( + parseComment( + `@${testBotName} add @kazydek for doc, review, maintenance. Please add akucharska for code, design. Please add derberg for infra and ideas`, + ), + ).toEqual({ + action: 'add', + contributors: { + kazydek: ['doc', 'review', 'maintenance'], + akucharska: ['code', 'design'], + derberg: ['infra', 'ideas'], + }, + }) + }) + + // TODO: Looks like this is gramatically incorrect + // test('Add multiple users in 1 hit - sentences seperated by commas :think:', () => { + // expect( + // parseComment( + // `@${testBotName} please add kazydek for doc, review, maintenance, please add akucharska for code, maintenance and please add derberg for doc, ideas`, + // ), + // ).toEqual({ + // action: 'add', + // contributors: { + // kazydek: ['doc', 'review', 'maintenance'], + // akucharska: ['code', 'maintenance'], + // derberg: ['doc', 'ideas'] + // }, + // }) + // }) + + test('Add multiple users in 1 hit - from seperate lines', () => { + expect( + parseComment( + ` + @all-contributors + please add @mikeattara for ideas, infra and design + please add @The24thDS for infra and review + please add @tbenning for code + ` + ), + ).toEqual({ + action: 'add', + contributors: { + mikeattara: ['ideas', 'infra', 'design'], + The24thDS: ['infra', 'review'], + tbenning: ['code'] + }, + }) + }) + + test('Intent unknown', () => { + expect( + parseComment(`@${testBotName} please lollmate for tool`), + ).toEqual({ + action: false, + }) + }) +})