Merge pull request #203 from joshdales/main

Assigns labels based on branch names

__tests__/branch.test.ts

@@ -0,0 +1,210 @@
+import {
+  getBranchName,
+  checkAnyBranch,
+  checkAllBranch,
+  toBranchMatchConfig,
+  BranchMatchConfig
+} from '../src/branch';
+import * as github from '@actions/github';
+
+jest.mock('@actions/core');
+jest.mock('@actions/github');
+
+describe('getBranchName', () => {
+  describe('when the pull requests base branch is requested', () => {
+    it('returns the base branch name', () => {
+      const result = getBranchName('base');
+      expect(result).toEqual('base-branch-name');
+    });
+  });
+
+  describe('when the pull requests head branch is requested', () => {
+    it('returns the head branch name', () => {
+      const result = getBranchName('head');
+      expect(result).toEqual('head-branch-name');
+    });
+  });
+});
+
+describe('checkAllBranch', () => {
+  beforeEach(() => {
+    github.context.payload.pull_request!.head = {
+      ref: 'test/feature/123'
+    };
+    github.context.payload.pull_request!.base = {
+      ref: 'main'
+    };
+  });
+
+  describe('when a single pattern is provided', () => {
+    describe('and the pattern matches the head branch', () => {
+      it('returns true', () => {
+        const result = checkAllBranch(['^test'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and the pattern does not match the head branch', () => {
+      it('returns false', () => {
+        const result = checkAllBranch(['^feature/'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when multiple patterns are provided', () => {
+    describe('and not all patterns matched', () => {
+      it('returns false', () => {
+        const result = checkAllBranch(['^test/', '^feature/'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+
+    describe('and all patterns match', () => {
+      it('returns true', () => {
+        const result = checkAllBranch(['^test/', '/feature/'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and no patterns match', () => {
+      it('returns false', () => {
+        const result = checkAllBranch(['^feature/', '/test$'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when the branch to check is specified as the base branch', () => {
+    describe('and the pattern matches the base branch', () => {
+      it('returns true', () => {
+        const result = checkAllBranch(['^main$'], 'base');
+        expect(result).toBe(true);
+      });
+    });
+  });
+});
+
+describe('checkAnyBranch', () => {
+  beforeEach(() => {
+    github.context.payload.pull_request!.head = {
+      ref: 'test/feature/123'
+    };
+    github.context.payload.pull_request!.base = {
+      ref: 'main'
+    };
+  });
+
+  describe('when a single pattern is provided', () => {
+    describe('and the pattern matches the head branch', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^test'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and the pattern does not match the head branch', () => {
+      it('returns false', () => {
+        const result = checkAnyBranch(['^feature/'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when multiple patterns are provided', () => {
+    describe('and at least one pattern matches', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^test/', '^feature/'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and all patterns match', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^test/', '/feature/'], 'head');
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('and no patterns match', () => {
+      it('returns false', () => {
+        const result = checkAnyBranch(['^feature/', '/test$'], 'head');
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe('when the branch to check is specified as the base branch', () => {
+    describe('and the pattern matches the base branch', () => {
+      it('returns true', () => {
+        const result = checkAnyBranch(['^main$'], 'base');
+        expect(result).toBe(true);
+      });
+    });
+  });
+});
+
+describe('toBranchMatchConfig', () => {
+  describe('when there are no branch keys in the config', () => {
+    const config = {'changed-files': [{any: ['testing']}]};
+
+    it('returns an empty object', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('when the config contains a head-branch option', () => {
+    const config = {'head-branch': ['testing']};
+
+    it('sets headBranch in the matchConfig', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual<BranchMatchConfig>({
+        headBranch: ['testing']
+      });
+    });
+
+    describe('and the matching option is a string', () => {
+      const stringConfig = {'head-branch': 'testing'};
+
+      it('sets headBranch in the matchConfig', () => {
+        const result = toBranchMatchConfig(stringConfig);
+        expect(result).toEqual<BranchMatchConfig>({
+          headBranch: ['testing']
+        });
+      });
+    });
+  });
+
+  describe('when the config contains a base-branch option', () => {
+    const config = {'base-branch': ['testing']};
+    it('sets baseBranch in the matchConfig', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual<BranchMatchConfig>({
+        baseBranch: ['testing']
+      });
+    });
+
+    describe('and the matching option is a string', () => {
+      const stringConfig = {'base-branch': 'testing'};
+
+      it('sets baseBranch in the matchConfig', () => {
+        const result = toBranchMatchConfig(stringConfig);
+        expect(result).toEqual<BranchMatchConfig>({
+          baseBranch: ['testing']
+        });
+      });
+    });
+  });
+
+  describe('when the config contains both a base-branch and head-branch option', () => {
+    const config = {'base-branch': ['testing'], 'head-branch': ['testing']};
+    it('sets headBranch and baseBranch in the matchConfig', () => {
+      const result = toBranchMatchConfig(config);
+      expect(result).toEqual<BranchMatchConfig>({
+        baseBranch: ['testing'],
+        headBranch: ['testing']
+      });
+    });
+  });
+});

__tests__/changedFiles.test.ts

@@ -0,0 +1,106 @@
+import {
+  ChangedFilesMatchConfig,
+  checkAllChangedFiles,
+  checkAnyChangedFiles,
+  toChangedFilesMatchConfig
+} from '../src/changedFiles';
+
+jest.mock('@actions/core');
+jest.mock('@actions/github');
+
+describe('checkAllChangedFiles', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when the globs match every file that has been changed', () => {
+    const globs = ['*.txt'];
+
+    it('returns true', () => {
+      const result = checkAllChangedFiles(changedFiles, globs);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe(`when the globs don't match every file that has changed`, () => {
+    const globs = ['foo.txt'];
+
+    it('returns false', () => {
+      const result = checkAllChangedFiles(changedFiles, globs);
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('checkAnyChangedFiles', () => {
+  const changedFiles = ['foo.txt', 'bar.txt'];
+
+  describe('when any glob matches any of the files that have changed', () => {
+    const globs = ['*.txt', '*.md'];
+
+    it('returns true', () => {
+      const result = checkAnyChangedFiles(changedFiles, globs);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('when none of the globs match any files that have changed', () => {
+    const globs = ['*.md'];
+
+    it('returns false', () => {
+      const result = checkAnyChangedFiles(changedFiles, globs);
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('toChangedFilesMatchConfig', () => {
+  describe(`when there is no 'changed-files' key in the config`, () => {
+    const config = {'head-branch': 'test'};
+
+    it('returns an empty object', () => {
+      const result = toChangedFilesMatchConfig(config);
+      expect(result).toEqual<ChangedFilesMatchConfig>({});
+    });
+  });
+
+  describe(`when there is a 'changed-files' key in the config`, () => {
+    describe('and the value is an array of strings', () => {
+      const config = {'changed-files': ['testing']};
+
+      it('sets the value in the config object', () => {
+        const result = toChangedFilesMatchConfig(config);
+        expect(result).toEqual<ChangedFilesMatchConfig>({
+          changedFiles: ['testing']
+        });
+      });
+    });
+
+    describe('and the value is a string', () => {
+      const config = {'changed-files': 'testing'};
+
+      it(`sets the string as an array in the config object`, () => {
+        const result = toChangedFilesMatchConfig(config);
+        expect(result).toEqual<ChangedFilesMatchConfig>({
+          changedFiles: ['testing']
+        });
+      });
+    });
+
+    describe('but the value is an empty string', () => {
+      const config = {'changed-files': ''};
+
+      it(`returns an empty object`, () => {
+        const result = toChangedFilesMatchConfig(config);
+        expect(result).toEqual<ChangedFilesMatchConfig>({});
+      });
+    });
+
+    describe('but the value is an empty array', () => {
+      const config = {'changed-files': []};
+
+      it(`returns an empty object`, () => {
+        const result = toChangedFilesMatchConfig(config);
+        expect(result).toEqual<ChangedFilesMatchConfig>({});
+      });
+    });
+  });
+});

__tests__/fixtures/all_options.yml

@@ -0,0 +1,14 @@
+label1:
+  - any:
+      - changed-files: ['glob']
+      - head-branch: ['regexp']
+      - base-branch: ['regexp']
+  - all:
+      - changed-files: ['glob']
+      - head-branch: ['regexp']
+      - base-branch: ['regexp']
+
+label2:
+  - changed-files: ['glob']
+  - head-branch: ['regexp']
+  - base-branch: ['regexp']

__tests__/fixtures/any_and_all.yml

@@ -0,0 +1,6 @@
+tests:
+  - any:
+      - head-branch: ['^tests/', '^test/']
+      - changed-files: ['tests/**/*']
+  - all:
+      - changed-files: ['!tests/requirements.txt']

__tests__/fixtures/branches.yml

@@ -0,0 +1,11 @@
+test-branch:
+  - head-branch: '^test/'
+
+feature-branch:
+  - head-branch: '/feature/'
+
+bug-branch:
+  - head-branch: '^bug/|fix/'
+
+array-branch:
+  - head-branch: ['^array/']

__tests__/fixtures/not_supported.yml

@@ -0,0 +1,3 @@
+label:
+  - all:
+      - unknown: 'this-is-not-supported'

__tests__/fixtures/only_pdfs.yml

@@ -1,2 +1,2 @@
 touched-a-pdf-file:
-  - any: ['*.pdf']
+  - changed-files: ['*.pdf']

__tests__/labeler.test.ts

@@ -1,6 +1,13 @@
-import {checkGlobs} from '../src/labeler';
-
+import {
+  checkMatchConfigs,
+  MatchConfig,
+  toMatchConfig,
+  getLabelConfigMapFromObject,
+  BaseMatchConfig
+} from '../src/labeler';
+import * as yaml from 'js-yaml';
 import * as core from '@actions/core';
+import * as fs from 'fs';
 
 jest.mock('@actions/core');
 
@@ -10,20 +17,124 @@ beforeAll(() => {
   });
 });
 
-const matchConfig = [{any: ['*.txt']}];
+const loadYaml = (filepath: string) => {
+  const loadedFile = fs.readFileSync(filepath);
+  const content = Buffer.from(loadedFile).toString();
+  return yaml.load(content);
+};
 
-describe('checkGlobs', () => {
-  it('returns true when our pattern does match changed files', () => {
-    const changedFiles = ['foo.txt', 'bar.txt'];
-    const result = checkGlobs(changedFiles, matchConfig);
+describe('getLabelConfigMapFromObject', () => {
+  const yamlObject = loadYaml('__tests__/fixtures/all_options.yml');
+  const expected = new Map<string, MatchConfig[]>();
+  expected.set('label1', [
+    {
+      any: [
+        {changedFiles: ['glob']},
+        {baseBranch: undefined, headBranch: ['regexp']},
+        {baseBranch: ['regexp'], headBranch: undefined}
+      ]
+    },
+    {
+      all: [
+        {changedFiles: ['glob']},
+        {baseBranch: undefined, headBranch: ['regexp']},
+        {baseBranch: ['regexp'], headBranch: undefined}
+      ]
+    }
+  ]);
+  expected.set('label2', [
+    {
+      any: [
+        {changedFiles: ['glob']},
+        {baseBranch: undefined, headBranch: ['regexp']},
+        {baseBranch: ['regexp'], headBranch: undefined}
+      ]
+    }
+  ]);
 
-    expect(result).toBeTruthy();
-  });
-
-  it('returns false when our pattern does not match changed files', () => {
-    const changedFiles = ['foo.docx'];
-    const result = checkGlobs(changedFiles, matchConfig);
-
-    expect(result).toBeFalsy();
+  it('returns a MatchConfig', () => {
+    const result = getLabelConfigMapFromObject(yamlObject);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('toMatchConfig', () => {
+  describe('when all expected config options are present', () => {
+    const config = {
+      'changed-files': ['testing-files'],
+      'head-branch': ['testing-head'],
+      'base-branch': ['testing-base']
+    };
+    const expected: BaseMatchConfig = {
+      changedFiles: ['testing-files'],
+      headBranch: ['testing-head'],
+      baseBranch: ['testing-base']
+    };
+
+    it('returns a MatchConfig object with all options', () => {
+      const result = toMatchConfig(config);
+      expect(result).toEqual(expected);
+    });
+
+    describe('and there are also unexpected options present', () => {
+      config['test-test'] = 'testing';
+
+      it('does not include the unexpected items in the returned MatchConfig object', () => {
+        const result = toMatchConfig(config);
+        expect(result).toEqual(expected);
+      });
+    });
+  });
+});
+
+describe('checkMatchConfigs', () => {
+  describe('when a single match config is provided', () => {
+    const matchConfig: MatchConfig[] = [{any: [{changedFiles: ['*.txt']}]}];
+
+    it('returns true when our pattern does match changed files', () => {
+      const changedFiles = ['foo.txt', 'bar.txt'];
+      const result = checkMatchConfigs(changedFiles, matchConfig);
+
+      expect(result).toBeTruthy();
+    });
+
+    it('returns false when our pattern does not match changed files', () => {
+      const changedFiles = ['foo.docx'];
+      const result = checkMatchConfigs(changedFiles, matchConfig);
+
+      expect(result).toBeFalsy();
+    });
+
+    it('returns true when either the branch or changed files patter matches', () => {
+      const matchConfig: MatchConfig[] = [
+        {any: [{changedFiles: ['*.txt']}, {headBranch: ['some-branch']}]}
+      ];
+      const changedFiles = ['foo.txt', 'bar.txt'];
+
+      const result = checkMatchConfigs(changedFiles, matchConfig);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('when multiple MatchConfigs are supplied', () => {
+    const matchConfig: MatchConfig[] = [
+      {any: [{changedFiles: ['*.txt']}]},
+      {any: [{headBranch: ['some-branch']}]}
+    ];
+    const changedFiles = ['foo.txt', 'bar.md'];
+
+    it('returns false when only one config matches', () => {
+      const result = checkMatchConfigs(changedFiles, matchConfig);
+      expect(result).toBe(false);
+    });
+
+    it('returns true when only both config matches', () => {
+      const matchConfig: MatchConfig[] = [
+        {any: [{changedFiles: ['*.txt']}]},
+        {any: [{headBranch: ['head-branch']}]}
+      ];
+      const result = checkMatchConfigs(changedFiles, matchConfig);
+      expect(result).toBe(true);
+    });
   });
 });

__tests__/main.test.ts

@@ -15,7 +15,10 @@ const paginateMock = jest.spyOn(gh, 'paginate');
 const getPullMock = jest.spyOn(gh.rest.pulls, 'get');
 
 const yamlFixtures = {
-  'only_pdfs.yml': fs.readFileSync('__tests__/fixtures/only_pdfs.yml')
+  'branches.yml': fs.readFileSync('__tests__/fixtures/branches.yml'),
+  'only_pdfs.yml': fs.readFileSync('__tests__/fixtures/only_pdfs.yml'),
+  'not_supported.yml': fs.readFileSync('__tests__/fixtures/not_supported.yml'),
+  'any_and_all.yml': fs.readFileSync('__tests__/fixtures/any_and_all.yml')
 };
 
 afterAll(() => jest.restoreAllMocks());
@@ -47,6 +50,14 @@ describe('run', () => {
     expect(addLabelsMock).toHaveBeenCalledTimes(0);
   });
 
+  it('does not add a label when the match config options are not supported', async () => {
+    usingLabelerConfigYaml('not_supported.yml');
+    await run();
+
+    expect(addLabelsMock).toHaveBeenCalledTimes(0);
+    expect(removeLabelMock).toHaveBeenCalledTimes(0);
+  });
+
   it('(with sync-labels: true) it deletes preexisting PR labels that no longer match the glob pattern', async () => {
     const mockInput = {
       'repo-token': 'foo',
@@ -102,6 +113,87 @@ describe('run', () => {
     expect(addLabelsMock).toHaveBeenCalledTimes(0);
     expect(removeLabelMock).toHaveBeenCalledTimes(0);
   });
+
+  it('adds labels based on the branch names that match the regexp pattern', async () => {
+    github.context.payload.pull_request!.head = {ref: 'test/testing-time'};
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(addLabelsMock).toHaveBeenCalledTimes(1);
+    expect(addLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['test-branch']
+    });
+  });
+
+  it('adds multiple labels based on branch names that match different regexp patterns', async () => {
+    github.context.payload.pull_request!.head = {
+      ref: 'test/feature/123'
+    };
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(addLabelsMock).toHaveBeenCalledTimes(1);
+    expect(addLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['test-branch', 'feature-branch']
+    });
+  });
+
+  it('can support multiple branches by batching', async () => {
+    github.context.payload.pull_request!.head = {ref: 'fix/123'};
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(addLabelsMock).toHaveBeenCalledTimes(1);
+    expect(addLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['bug-branch']
+    });
+  });
+
+  it('can support multiple branches by providing an array', async () => {
+    github.context.payload.pull_request!.head = {ref: 'array/123'};
+    usingLabelerConfigYaml('branches.yml');
+    await run();
+
+    expect(addLabelsMock).toHaveBeenCalledTimes(1);
+    expect(addLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['array-branch']
+    });
+  });
+
+  it('adds a label when matching any and all patterns are provided', async () => {
+    usingLabelerConfigYaml('any_and_all.yml');
+    mockGitHubResponseChangedFiles('tests/test.ts');
+    await run();
+
+    expect(addLabelsMock).toHaveBeenCalledTimes(1);
+    expect(addLabelsMock).toHaveBeenCalledWith({
+      owner: 'monalisa',
+      repo: 'helloworld',
+      issue_number: 123,
+      labels: ['tests']
+    });
+  });
+
+  it('does not add a label when not all any and all patterns are matched', async () => {
+    usingLabelerConfigYaml('any_and_all.yml');
+    mockGitHubResponseChangedFiles('tests/requirements.txt');
+    await run();
+
+    expect(addLabelsMock).toHaveBeenCalledTimes(0);
+    expect(removeLabelMock).toHaveBeenCalledTimes(0);
+  });
 });
 
 function usingLabelerConfigYaml(fixtureName: keyof typeof yamlFixtures): void {