feat(exempt): add new options to exempt the milestones (#279)

* feat(exempt): add new options to exempt the milestones

closes #270

* test(milestones): add coverage

* test(issue): add coverage

* chore(rebase): fix all errors due to the rebase

also made some changes regarding the change I made with the lint scripts and prettier. I did not saw that some scripts were already here and I created to more to keep the old ones as well

* test(milestone): add coverage

* chore(index): update index

* fix(checks): remove checks over optional number options

the code was actually handling the case where the values are NaN so it's fine

src/classes/issue.spec.ts

@@ -0,0 +1,208 @@
+import {IIssue} from '../interfaces/issue';
+import {IMilestone} from '../interfaces/milestone';
+import {IssueProcessorOptions, Label} from '../IssueProcessor';
+import {Issue} from './issue';
+
+describe('Issue', (): void => {
+  let issue: Issue;
+  let optionsInterface: IssueProcessorOptions;
+  let issueInterface: IIssue;
+
+  beforeEach((): void => {
+    optionsInterface = {
+      ascending: false,
+      closeIssueLabel: '',
+      closeIssueMessage: '',
+      closePrLabel: '',
+      closePrMessage: '',
+      daysBeforeClose: 0,
+      daysBeforeIssueClose: 0,
+      daysBeforeIssueStale: 0,
+      daysBeforePrClose: 0,
+      daysBeforePrStale: 0,
+      daysBeforeStale: 0,
+      debugOnly: false,
+      deleteBranch: false,
+      exemptIssueLabels: '',
+      exemptIssueMilestones: '',
+      exemptMilestones: '',
+      exemptPrLabels: '',
+      exemptPrMilestones: '',
+      onlyLabels: '',
+      operationsPerRun: 0,
+      removeStaleWhenUpdated: false,
+      repoToken: '',
+      skipStaleIssueMessage: false,
+      skipStalePrMessage: false,
+      staleIssueMessage: '',
+      stalePrMessage: '',
+      startDate: undefined,
+      stalePrLabel: 'dummy-stale-pr-label',
+      staleIssueLabel: 'dummy-stale-issue-label'
+    };
+    issueInterface = {
+      title: 'dummy-title',
+      number: 8,
+      created_at: 'dummy-created-at',
+      updated_at: 'dummy-updated-at',
+      labels: [
+        {
+          name: 'dummy-name'
+        }
+      ],
+      pull_request: {},
+      state: 'dummy-state',
+      locked: false,
+      milestone: {
+        title: 'dummy-milestone'
+      }
+    };
+    issue = new Issue(optionsInterface, issueInterface);
+  });
+
+  describe('constructor()', (): void => {
+    it('should set the title with the given issue title', (): void => {
+      expect.assertions(1);
+
+      expect(issue.title).toStrictEqual('dummy-title');
+    });
+
+    it('should set the number with the given issue number', (): void => {
+      expect.assertions(1);
+
+      expect(issue.number).toStrictEqual(8);
+    });
+
+    it('should set the created_at with the given issue created_at', (): void => {
+      expect.assertions(1);
+
+      expect(issue.created_at).toStrictEqual('dummy-created-at');
+    });
+
+    it('should set the updated_at with the given issue updated_at', (): void => {
+      expect.assertions(1);
+
+      expect(issue.updated_at).toStrictEqual('dummy-updated-at');
+    });
+
+    it('should set the labels with the given issue labels', (): void => {
+      expect.assertions(1);
+
+      expect(issue.labels).toStrictEqual([
+        {
+          name: 'dummy-name'
+        } as Label
+      ]);
+    });
+
+    it('should set the pull_request with the given issue pull_request', (): void => {
+      expect.assertions(1);
+
+      expect(issue.pull_request).toStrictEqual({});
+    });
+
+    it('should set the state with the given issue state', (): void => {
+      expect.assertions(1);
+
+      expect(issue.state).toStrictEqual('dummy-state');
+    });
+
+    it('should set the locked with the given issue locked', (): void => {
+      expect.assertions(1);
+
+      expect(issue.locked).toStrictEqual(false);
+    });
+
+    it('should set the milestone with the given issue milestone', (): void => {
+      expect.assertions(1);
+
+      expect(issue.milestone).toStrictEqual({
+        title: 'dummy-milestone'
+      } as IMilestone);
+    });
+
+    describe('when the given issue pull_request is not set', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = undefined;
+        issue = new Issue(optionsInterface, issueInterface);
+      });
+
+      it('should set the isPullRequest to false', (): void => {
+        expect.assertions(1);
+
+        expect(issue.isPullRequest).toStrictEqual(false);
+      });
+    });
+
+    describe('when the given issue pull_request is set', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = {};
+        issue = new Issue(optionsInterface, issueInterface);
+      });
+
+      it('should set the isPullRequest to true', (): void => {
+        expect.assertions(1);
+
+        expect(issue.isPullRequest).toStrictEqual(true);
+      });
+    });
+
+    describe('when the given issue is not a pull request', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = undefined;
+        issue = new Issue(optionsInterface, issueInterface);
+      });
+
+      it('should set the staleLabel with the given option staleIssueLabel', (): void => {
+        expect.assertions(1);
+
+        expect(issue.staleLabel).toStrictEqual('dummy-stale-issue-label');
+      });
+    });
+
+    describe('when the given issue is a pull request', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = {};
+        issue = new Issue(optionsInterface, issueInterface);
+      });
+
+      it('should set the staleLabel with the given option stalePrLabel', (): void => {
+        expect.assertions(1);
+
+        expect(issue.staleLabel).toStrictEqual('dummy-stale-pr-label');
+      });
+    });
+
+    describe('when the given issue does not contains the stale label', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = undefined;
+        issueInterface.labels = [];
+        issue = new Issue(optionsInterface, issueInterface);
+      });
+
+      it('should set the isStale to false', (): void => {
+        expect.assertions(1);
+
+        expect(issue.isStale).toStrictEqual(false);
+      });
+    });
+
+    describe('when the given issue contains the stale label', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = undefined;
+        issueInterface.labels = [
+          {
+            name: 'dummy-stale-issue-label'
+          } as Label
+        ];
+        issue = new Issue(optionsInterface, issueInterface);
+      });
+
+      it('should set the isStale to true', (): void => {
+        expect.assertions(1);
+
+        expect(issue.isStale).toStrictEqual(true);
+      });
+    });
+  });
+});

src/classes/issue.ts

@@ -0,0 +1,48 @@
+import {isLabeled} from '../functions/is-labeled';
+import {isPullRequest} from '../functions/is-pull-request';
+import {IIssue} from '../interfaces/issue';
+import {IMilestone} from '../interfaces/milestone';
+import {IssueProcessorOptions, Label} from '../IssueProcessor';
+import {IsoDateString} from '../types/iso-date-string';
+
+export class Issue implements IIssue {
+  private readonly _options: IssueProcessorOptions;
+  readonly title: string;
+  readonly number: number;
+  created_at: IsoDateString;
+  updated_at: IsoDateString;
+  readonly labels: Label[];
+  readonly pull_request: Object | null | undefined;
+  readonly state: string;
+  readonly locked: boolean;
+  readonly milestone: IMilestone | undefined;
+  readonly isPullRequest: boolean;
+  readonly staleLabel: string;
+  isStale: boolean;
+
+  constructor(
+    options: Readonly<IssueProcessorOptions>,
+    issue: Readonly<IIssue>
+  ) {
+    this._options = options;
+    this.title = issue.title;
+    this.number = issue.number;
+    this.created_at = issue.created_at;
+    this.updated_at = issue.updated_at;
+    this.labels = issue.labels;
+    this.pull_request = issue.pull_request;
+    this.state = issue.state;
+    this.locked = issue.locked;
+    this.milestone = issue.milestone;
+
+    this.isPullRequest = isPullRequest(this);
+    this.staleLabel = this._getStaleLabel();
+    this.isStale = isLabeled(this, this.staleLabel);
+  }
+
+  private _getStaleLabel(): string {
+    return this.isPullRequest
+      ? this._options.stalePrLabel
+      : this._options.staleIssueLabel;
+  }
+}

src/classes/loggers/issue-logger.spec.ts

@@ -1,4 +1,4 @@
-import {Issue} from '../IssueProcessor';
+import {Issue} from '../issue';
 import {IssueLogger} from './issue-logger';
 import * as core from '@actions/core';
 

src/classes/loggers/issue-logger.ts

@@ -1,11 +1,11 @@
 import * as core from '@actions/core';
-import {Issue} from '../IssueProcessor';
+import {Issue} from '../issue';
 import {Logger} from './logger';
 
 export class IssueLogger implements Logger {
   private readonly _issue: Issue;
 
-  constructor(issue: Readonly<Issue>) {
+  constructor(issue: Issue) {
     this._issue = issue;
   }
 

src/classes/milestones.spec.ts

@@ -0,0 +1,596 @@
+import {IIssue} from '../interfaces/issue';
+import {IssueProcessorOptions} from '../IssueProcessor';
+import {Issue} from './issue';
+import {Milestones} from './milestones';
+
+describe('Milestones', (): void => {
+  let milestones: Milestones;
+  let optionsInterface: IssueProcessorOptions;
+  let issue: Issue;
+  let issueInterface: IIssue;
+
+  beforeEach((): void => {
+    optionsInterface = {
+      ascending: false,
+      closeIssueLabel: '',
+      closeIssueMessage: '',
+      closePrLabel: '',
+      closePrMessage: '',
+      daysBeforeClose: 0,
+      daysBeforeIssueClose: 0,
+      daysBeforeIssueStale: 0,
+      daysBeforePrClose: 0,
+      daysBeforePrStale: 0,
+      daysBeforeStale: 0,
+      debugOnly: false,
+      deleteBranch: false,
+      exemptIssueLabels: '',
+      exemptPrLabels: '',
+      onlyLabels: '',
+      operationsPerRun: 0,
+      removeStaleWhenUpdated: false,
+      repoToken: '',
+      skipStaleIssueMessage: false,
+      skipStalePrMessage: false,
+      staleIssueLabel: '',
+      staleIssueMessage: '',
+      stalePrLabel: '',
+      stalePrMessage: '',
+      startDate: undefined,
+      exemptIssueMilestones: '',
+      exemptPrMilestones: '',
+      exemptMilestones: ''
+    };
+    issueInterface = {
+      created_at: '',
+      locked: false,
+      milestone: undefined,
+      number: 0,
+      pull_request: undefined,
+      state: '',
+      title: '',
+      updated_at: '',
+      labels: []
+    };
+  });
+
+  describe('shouldExemptMilestones()', (): void => {
+    describe('when the given issue is not a pull request', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = undefined;
+      });
+
+      describe('when the given options are not configured to exempt a milestone', (): void => {
+        beforeEach((): void => {
+          optionsInterface.exemptMilestones = '';
+        });
+
+        describe('when the given options are not configured to exempt an issue milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptIssueMilestones = '';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+        });
+
+        describe('when the given options are configured to exempt an issue milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptIssueMilestones =
+              'dummy-exempt-issue-milestone';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt issue milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt issue milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-issue-milestone'
+              };
+            });
+
+            it('should return true', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(true);
+            });
+          });
+        });
+      });
+
+      describe('when the given options are configured to exempt a milestone', (): void => {
+        beforeEach((): void => {
+          optionsInterface.exemptMilestones = 'dummy-exempt-milestone';
+        });
+
+        describe('when the given options are not configured to exempt an issue milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptIssueMilestones = '';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-milestone'
+              };
+            });
+
+            it('should return true', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(true);
+            });
+          });
+        });
+
+        describe('when the given options are configured to exempt an issue milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptIssueMilestones =
+              'dummy-exempt-issue-milestone';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt issue milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt issue milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-issue-milestone'
+              };
+            });
+
+            it('should return true', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(true);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-milestone'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+        });
+      });
+    });
+
+    describe('when the given issue is a pull request', (): void => {
+      beforeEach((): void => {
+        issueInterface.pull_request = {};
+      });
+
+      describe('when the given options are not configured to exempt a milestone', (): void => {
+        beforeEach((): void => {
+          optionsInterface.exemptMilestones = '';
+        });
+
+        describe('when the given options are not configured to exempt a pull request milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptPrMilestones = '';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+        });
+
+        describe('when the given options are configured to exempt a pull request milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptPrMilestones = 'dummy-exempt-pr-milestone';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt pull request milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt pull request milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-pr-milestone'
+              };
+            });
+
+            it('should return true', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(true);
+            });
+          });
+        });
+      });
+
+      describe('when the given options are configured to exempt a milestone', (): void => {
+        beforeEach((): void => {
+          optionsInterface.exemptMilestones = 'dummy-exempt-milestone';
+        });
+
+        describe('when the given options are not configured to exempt a pull request milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptPrMilestones = '';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-milestone'
+              };
+            });
+
+            it('should return true', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(true);
+            });
+          });
+        });
+
+        describe('when the given options are configured to exempt a pull request milestone', (): void => {
+          beforeEach((): void => {
+            optionsInterface.exemptPrMilestones = 'dummy-exempt-pr-milestone';
+          });
+
+          describe('when the given issue does not have a milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = undefined;
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt pull request milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt pull request milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-pr-milestone'
+              };
+            });
+
+            it('should return true', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(true);
+            });
+          });
+
+          describe('when the given issue does have a milestone different than the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-title'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+
+          describe('when the given issue does have a milestone equaling the exempt milestone', (): void => {
+            beforeEach((): void => {
+              issueInterface.milestone = {
+                title: 'dummy-exempt-milestone'
+              };
+            });
+
+            it('should return false', (): void => {
+              expect.assertions(1);
+              issue = new Issue(optionsInterface, issueInterface);
+              milestones = new Milestones(optionsInterface, issue);
+
+              const result = milestones.shouldExemptMilestones();
+
+              expect(result).toStrictEqual(false);
+            });
+          });
+        });
+      });
+    });
+  });
+});

src/classes/milestones.ts

@@ -0,0 +1,59 @@
+import deburr from 'lodash.deburr';
+import {wordsToList} from '../functions/words-to-list';
+import {IssueProcessorOptions} from '../IssueProcessor';
+import {Issue} from './issue';
+
+type CleanMilestone = string;
+
+export class Milestones {
+  private static _cleanMilestone(label: Readonly<string>): CleanMilestone {
+    return deburr(label.toLowerCase());
+  }
+
+  private readonly _options: IssueProcessorOptions;
+  private readonly _issue: Issue;
+
+  constructor(options: Readonly<IssueProcessorOptions>, issue: Issue) {
+    this._options = options;
+    this._issue = issue;
+  }
+
+  shouldExemptMilestones(): boolean {
+    const exemptMilestones: string[] = this._getExemptMilestones();
+
+    return exemptMilestones.some((exemptMilestone: Readonly<string>): boolean =>
+      this._hasMilestone(exemptMilestone)
+    );
+  }
+
+  private _getExemptMilestones(): string[] {
+    return wordsToList(
+      this._issue.isPullRequest
+        ? this._getExemptPullRequestMilestones()
+        : this._getExemptIssueMilestones()
+    );
+  }
+
+  private _getExemptIssueMilestones(): string {
+    return this._options.exemptIssueMilestones !== ''
+      ? this._options.exemptIssueMilestones
+      : this._options.exemptMilestones;
+  }
+
+  private _getExemptPullRequestMilestones(): string {
+    return this._options.exemptPrMilestones !== ''
+      ? this._options.exemptPrMilestones
+      : this._options.exemptMilestones;
+  }
+
+  private _hasMilestone(milestone: Readonly<string>): boolean {
+    if (!this._issue.milestone) {
+      return false;
+    }
+
+    return (
+      Milestones._cleanMilestone(milestone) ===
+      Milestones._cleanMilestone(this._issue.milestone.title)
+    );
+  }
+}