diff --git a/src/app/core/constants/milestone-anomalies.constants.ts b/src/app/core/constants/milestone-anomalies.constants.ts
new file mode 100644
index 000000000..99bcd48db
--- /dev/null
+++ b/src/app/core/constants/milestone-anomalies.constants.ts
@@ -0,0 +1,6 @@
+export enum MilestoneAnomaliesStatus {
+  NoDeadline = 'No Deadline',
+  PastDeadline = 'Past Deadline',
+  ClosedMilestoneAnomaly = 'Closed milestone with open issues or unmerged pull requests',
+  MultipleOpenMilestoneAnomaly = 'Multiple milestones are left open'
+}
diff --git a/src/app/core/models/anomaly.model.ts b/src/app/core/models/anomaly.model.ts
new file mode 100644
index 000000000..01311792f
--- /dev/null
+++ b/src/app/core/models/anomaly.model.ts
@@ -0,0 +1,13 @@
+// Represents an anomaly state of the objects used in the app (e.g. Milestones, Issues etc).
+// Should not be used to represent errors that affects normal functionality of the app.
+
+export abstract class Anomaly {
+  abstract readonly anomalyType: string;
+  anomaly: string;
+
+  constructor(anomaly: string) {
+    this.anomaly = anomaly;
+  }
+
+  abstract getDescription(): string;
+}
diff --git a/src/app/core/models/milestone-anomaly.model.ts b/src/app/core/models/milestone-anomaly.model.ts
new file mode 100644
index 000000000..7266ea740
--- /dev/null
+++ b/src/app/core/models/milestone-anomaly.model.ts
@@ -0,0 +1,40 @@
+import { Anomaly } from './anomaly.model';
+import { Milestone } from './milestone.model';
+
+export abstract class MilestoneAnomaly extends Anomaly {
+  readonly anomalyType = 'MilestoneAnomaly';
+
+  constructor(anomaly: string) {
+    super(anomaly);
+  }
+}
+
+// Represents an anomaly that is related to a single milestone
+export class SingleMilestoneAnomaly extends MilestoneAnomaly {
+  milestone: Milestone;
+
+  constructor(milestone: Milestone, anomaly: string) {
+    super(anomaly);
+    this.milestone = milestone;
+  }
+
+  getDescription(): string {
+    return `${this.milestone.title}: ${this.anomaly}`;
+  }
+}
+
+// Represents an anomaly that is related to multiple milestones
+export class GeneralMilestoneAnomaly extends MilestoneAnomaly {
+  milestones: Milestone[];
+
+  constructor(milestones: Milestone[], anomaly: string) {
+    super(anomaly);
+    this.milestones = milestones;
+  }
+
+  getDescription(): string {
+    const milestoneTitles = this.milestones.map((milestone) => milestone.title).join(', ');
+
+    return `${this.anomaly}: ${milestoneTitles}`;
+  }
+}
diff --git a/src/app/core/services/milestone.service.ts b/src/app/core/services/milestone.service.ts
index 64d938ee2..a8baf120e 100644
--- a/src/app/core/services/milestone.service.ts
+++ b/src/app/core/services/milestone.service.ts
@@ -1,8 +1,14 @@
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
+
+import { replaceNewlinesWithBreakLines } from '../../shared/lib/html';
+import { MilestoneAnomaliesStatus } from '../constants/milestone-anomalies.constants';
+import { Issue } from '../models/issue.model';
+import { GeneralMilestoneAnomaly, MilestoneAnomaly, SingleMilestoneAnomaly } from '../models/milestone-anomaly.model';
 import { Milestone } from '../models/milestone.model';
 import { GithubService } from './github.service';
+import { IssueService } from './issue.service';
 
 @Injectable({
   providedIn: 'root'
@@ -15,6 +21,7 @@ import { GithubService } from './github.service';
 export class MilestoneService {
   milestones: Milestone[] = [];
   hasNoMilestones: boolean;
+  milestoneAnomalies: MilestoneAnomaly[] = [];
 
   constructor(private githubService: GithubService) {}
 
@@ -26,6 +33,7 @@ export class MilestoneService {
       map((response) => {
         this.milestones = this.parseMilestoneData(response);
         this.hasNoMilestones = response.length === 0;
+        this.updateMilestoneAnomalies();
         return response;
       })
     );
@@ -98,4 +106,119 @@ export class MilestoneService {
     }
     return latestClosedMilestone;
   }
+
+  /**
+   * Updates the MilestoneAnomalies associated with this milestoneService.
+   * This does not check for closed milestone with open issues or unmerged PR.
+   */
+  updateMilestoneAnomalies() {
+    // removes all previous milestone anomalies first.
+    this.milestoneAnomalies = [];
+
+    this.checkMilestoneDeadlineAnomalies();
+    this.checkMultipleOpenedMilestonesAnomaly();
+  }
+
+  getMilestoneAnomalies(): MilestoneAnomaly[] {
+    return this.milestoneAnomalies;
+  }
+
+  /**
+   * Checks if the milestones have any anomalies.
+   */
+  hasMilestoneAnomalies(): boolean {
+    return this.milestoneAnomalies.length > 0;
+  }
+
+  /**
+   * Checks whether a milestone has a deadline and whether the milestone has gone past deadline.
+   */
+  checkMilestoneDeadlineAnomalies() {
+    for (const milestone of this.milestones) {
+      if (!milestone.deadline) {
+        // Milestone has no deadline
+        const newAnomaly = new SingleMilestoneAnomaly(milestone, MilestoneAnomaliesStatus.NoDeadline);
+        this.milestoneAnomalies.push(newAnomaly);
+      } else if (milestone.state === 'open' && milestone.deadline < new Date()) {
+        // Milestone deadline has past
+        const newAnomaly = new SingleMilestoneAnomaly(milestone, MilestoneAnomaliesStatus.PastDeadline);
+        this.milestoneAnomalies.push(newAnomaly);
+      }
+    }
+  }
+
+  /**
+   * Checks for milestone anomalies related to milestone issues and PRs.
+   */
+  checkMilestoneIssuesAnomalies(issueService: IssueService) {
+    issueService.issues$.subscribe((issues: Issue[]) => {
+      this.updateClosedMilestoneWithOpenIssueOrPR(issues);
+    });
+  }
+
+  /**
+   * Checks if a closed milestone has open or unmerged PRs
+   * Loops through the issues, checks if the issue/PR is still open but the corresponding milestone is closed.
+   * Since this method is called from BehaviorSubject, to prevent adding of multiple copies of the same anomaly,
+   * filter the current milestone anomalies to remove all anomalies related to closed milestone anomalies with open issues/PRs
+   * first.
+   */
+  updateClosedMilestoneWithOpenIssueOrPR(issues: Issue[]) {
+    // Filtering the milestone anomalies.
+    this.milestoneAnomalies = this.milestoneAnomalies.filter((milestoneAnomaly) => {
+      return milestoneAnomaly.anomaly !== MilestoneAnomaliesStatus.ClosedMilestoneAnomaly;
+    });
+
+    const milestonesWithAnomaly: Set<Milestone> = new Set<Milestone>();
+    for (const issue of issues) {
+      const issueMilestone: Milestone = issue.milestone;
+      if (issue.state === 'OPEN' && issueMilestone && issueMilestone.state === 'CLOSED') {
+        milestonesWithAnomaly.add(issueMilestone);
+      }
+    }
+    for (const milestone of milestonesWithAnomaly) {
+      const newAnomaly = new SingleMilestoneAnomaly(milestone, MilestoneAnomaliesStatus.ClosedMilestoneAnomaly);
+      this.milestoneAnomalies.push(newAnomaly);
+    }
+  }
+
+  /**
+   * Checks if there are multiple open milestones.
+   */
+  checkMultipleOpenedMilestonesAnomaly() {
+    const allOpenMilestones: Milestone[] = [];
+    for (const milestone of this.milestones) {
+      if (milestone.state === 'open') {
+        allOpenMilestones.push(milestone);
+      }
+    }
+    if (allOpenMilestones.length > 1) {
+      // there are multiple open milestones.
+      const newAnomaly = new GeneralMilestoneAnomaly(allOpenMilestones, MilestoneAnomaliesStatus.MultipleOpenMilestoneAnomaly);
+      this.milestoneAnomalies = [newAnomaly, ...this.milestoneAnomalies];
+    }
+  }
+
+  /**
+   * Returns a string that contains all the current milestone anomalies.
+   * New line is created using `\n` symbols.
+   * When display using HTML, `\n` needs to be replaced with `<br>`.
+   */
+  getConsolidatedAnomaliesMessage(): string {
+    let message = null;
+    if (!this.hasMilestoneAnomalies) {
+      return message;
+    }
+
+    const milestoneAnomalies = this.getMilestoneAnomalies();
+    message = milestoneAnomalies.map((milestoneAnomaly) => `${milestoneAnomaly.getDescription()}`).join('\n');
+    return message;
+  }
+
+  /**
+   * Returns the anomalies message to be displayed using HTML
+   */
+  getConsolidatedAnomaliesMessageHTML(): string {
+    return replaceNewlinesWithBreakLines(this.getConsolidatedAnomaliesMessage());
+  }
 }
diff --git a/src/app/issues-viewer/issues-viewer.component.css b/src/app/issues-viewer/issues-viewer.component.css
index f77ed18bc..437ee7f5e 100644
--- a/src/app/issues-viewer/issues-viewer.component.css
+++ b/src/app/issues-viewer/issues-viewer.component.css
@@ -103,3 +103,56 @@
   box-sizing: border-box;
   padding: 0.5rem 1rem 0.5rem 0;
 }
+
+.main-content {
+  display: flex;
+  flex-direction: column;
+  flex-grow: 1;
+  overflow: hidden;
+  height: 100%;
+}
+
+.warning-card {
+  max-height: 200px;
+  display: flex;
+  flex-direction: column;
+  align-items: start;
+  background: #fff8e1;
+  border-left: 5px solid #fbc02d;
+  padding: 12px;
+  margin: 12px;
+}
+
+.warning-card .header {
+  display: flex;
+  align-items: center;
+  margin-bottom: 8px;
+  flex: 1;
+  max-height: 20px;
+  width: 100%;
+}
+
+.warning-card .mat-icon {
+  color: #fbc02d;
+}
+
+.warning-card .title {
+  flex: 1;
+  margin-left: 12px;
+  font-weight: bold;
+}
+
+.warning-card.button {
+  align-self: flex-start;
+}
+
+.warning-card .content {
+  overflow-y: auto;
+  flex: 1;
+  margin-left: 12px;
+  font-size: 14px;
+  max-height: 100px;
+  line-height: 1.5;
+  scrollbar-width: thin;
+  scrollbar-color: #fbc02d transparent;
+}
diff --git a/src/app/issues-viewer/issues-viewer.component.html b/src/app/issues-viewer/issues-viewer.component.html
index f98b4fb9b..5b7c7991c 100644
--- a/src/app/issues-viewer/issues-viewer.component.html
+++ b/src/app/issues-viewer/issues-viewer.component.html
@@ -8,11 +8,7 @@
       <mat-drawer-container class="drawer-container">
         <mat-drawer #sidenav mode="side" opened>
           <div class="left">
-            <app-filter-bar
-              [views$]="views"
-              (escapePressed)="sidenav.close()"
-              >
-            </app-filter-bar>
+            <app-filter-bar [views$]="views" (escapePressed)="sidenav.close()"> </app-filter-bar>
           </div>
         </mat-drawer>
         <mat-drawer-content>
@@ -25,17 +21,32 @@
                 >chevron_right</mat-icon
               >
             </div>
-            <div class="right">
-              <app-card-view
-                *ngFor="let group of this.groupService.groups"
-                class="issue-table"
-                #card
-                [ngStyle]="{ display: card.isLoading || card.issueLength > 0 ? 'initial' : 'none' }"
-                [group]="group"
-                [headers]="this.displayedColumns"
-                (issueLengthChange)="this.groupService.updateHiddenGroups($event, group)"
-              ></app-card-view>
-              <app-hidden-groups [groups]="this.groupService.hiddenGroups"></app-hidden-groups>
+            <div class="main-content">
+              <mat-card class="warning-card" *ngIf="this.isDisplayMilestoneAnomalies()">
+                <div class="header">
+                  <mat-icon color="warn">warning</mat-icon>
+                  <div class="title">Milestone Anomalies:</div>
+                  <button mat-icon-button (click)="dismissMilestoneAnomalies()">
+                    <mat-icon>close</mat-icon>
+                  </button>
+                </div>
+                <div class="content">
+                  <div [innerHTML]="this.milestoneService.getConsolidatedAnomaliesMessageHTML()"></div>
+                </div>
+              </mat-card>
+
+              <div class="right">
+                <app-card-view
+                  *ngFor="let group of this.groupService.groups"
+                  class="issue-table"
+                  #card
+                  [ngStyle]="{ display: card.isLoading || card.issueLength > 0 ? 'initial' : 'none' }"
+                  [group]="group"
+                  [headers]="this.displayedColumns"
+                  (issueLengthChange)="this.groupService.updateHiddenGroups($event, group)"
+                ></app-card-view>
+                <app-hidden-groups [groups]="this.groupService.hiddenGroups"></app-hidden-groups>
+              </div>
             </div>
           </div>
         </mat-drawer-content>
diff --git a/src/app/issues-viewer/issues-viewer.component.ts b/src/app/issues-viewer/issues-viewer.component.ts
index 800e9b937..3f7cf3c02 100644
--- a/src/app/issues-viewer/issues-viewer.component.ts
+++ b/src/app/issues-viewer/issues-viewer.component.ts
@@ -5,7 +5,7 @@ import { filter } from 'rxjs/operators';
 import { FiltersService } from '../core/services/filters.service';
 import { GithubService } from '../core/services/github.service';
 import { GroupService } from '../core/services/grouping/group.service';
-import { GroupingContextService } from '../core/services/grouping/grouping-context.service';
+import { GroupBy, GroupingContextService } from '../core/services/grouping/grouping-context.service';
 import { IssueService } from '../core/services/issue.service';
 import { LabelService } from '../core/services/label.service';
 import { MilestoneService } from '../core/services/milestone.service';
@@ -42,6 +42,9 @@ export class IssuesViewerComponent implements OnInit, AfterViewInit, OnDestroy {
   /** Hide or show the filter bar */
   showFilterBar = false;
 
+  // Hide or display milestone anomalies
+  showMilestoneAnomalies = true;
+
   constructor(
     public viewService: ViewService,
     public githubService: GithubService,
@@ -103,9 +106,29 @@ export class IssuesViewerComponent implements OnInit, AfterViewInit, OnDestroy {
     }
     this.groupService.resetGroups();
     this.availableGroupsSubscription = this.groupingContextService.getGroups().subscribe((x) => (this.groupService.groups = x));
+    this.showMilestoneAnomalies = true;
+    this.milestoneService.checkMilestoneIssuesAnomalies(this.issueService);
   }
 
   private toggleSidebar() {
     this.showFilterBar = !this.showFilterBar;
   }
+
+  private dismissMilestoneAnomalies() {
+    this.showMilestoneAnomalies = false;
+  }
+
+  /**
+   * Checks if the current GroupBy is by milestone.
+   */
+  private isGroupByMilestone() {
+    return this.groupingContextService.currGroupBy === GroupBy.Milestone;
+  }
+
+  /**
+   * Checks if the conditions to display the milestone anomalies warning card is met.
+   */
+  private isDisplayMilestoneAnomalies(): boolean {
+    return this.showMilestoneAnomalies && this.milestoneService.hasMilestoneAnomalies() && this.isGroupByMilestone();
+  }
 }
diff --git a/src/app/shared/filter-bar/filter-bar.component.html b/src/app/shared/filter-bar/filter-bar.component.html
index a92778f34..f951b7942 100644
--- a/src/app/shared/filter-bar/filter-bar.component.html
+++ b/src/app/shared/filter-bar/filter-bar.component.html
@@ -73,6 +73,7 @@
           </mat-option>
         </mat-select>
       </mat-form-field>
+
       <mat-form-field appearance="standard" class="filter-item">
         <mat-label>Milestone</mat-label>
         <mat-select
diff --git a/src/app/shared/filter-bar/filter-bar.component.ts b/src/app/shared/filter-bar/filter-bar.component.ts
index 87387a576..fa9439e6b 100644
--- a/src/app/shared/filter-bar/filter-bar.component.ts
+++ b/src/app/shared/filter-bar/filter-bar.component.ts
@@ -15,6 +15,7 @@ import {
 import { MatSelect } from '@angular/material/select';
 import { BehaviorSubject, Subscription } from 'rxjs';
 import { MilestoneOptions, SortOptions, StatusOptions, TypeOptions } from '../../core/constants/filter-options.constants';
+import { MilestoneAnomaly } from '../../core/models/milestone-anomaly.model';
 import { AssigneeService } from '../../core/services/assignee.service';
 import { Filter, FiltersService } from '../../core/services/filters.service';
 import { GroupBy, GroupingContextService } from '../../core/services/grouping/grouping-context.service';
@@ -162,5 +163,8 @@ export class FilterBarComponent implements OnInit, OnDestroy {
     event.preventDefault();
     event.stopImmediatePropagation();
   }
-}
 
+  handleUpdateMilestoneFilter({ milestones }: { milestones: string[] }) {
+    this.filtersService.updateFilters({ milestones: milestones });
+  }
+}
diff --git a/tests/constants/githubissue.constants.ts b/tests/constants/githubissue.constants.ts
index 6bd0df4ef..f3e2fd925 100644
--- a/tests/constants/githubissue.constants.ts
+++ b/tests/constants/githubissue.constants.ts
@@ -39,6 +39,11 @@ export const MILESTONE_ONE = {
   state: 'Open'
 };
 
+export const CLOSED_MILESTONE = {
+  title: 'Closed Milestone',
+  state: 'CLOSED'
+};
+
 export const ISSUE_WITH_EMPTY_DESCRIPTION = new GithubIssue({
   id: '574085971',
   number: 92,
@@ -198,6 +203,26 @@ export const ISSUE_WITH_ASSIGNEES = new GithubIssue({
   isDraft: false
 });
 
+export const OPEN_ISSUE_WITH_CLOSED_MILESTONE = new GithubIssue({
+  id: '551732011',
+  number: 91,
+  assignees: [USER_ANUBHAV_DETAILS],
+  body: 'Screen freezes every few minutes',
+  created_at: '2020-01-18T07:01:45Z',
+  labels: [GITHUB_LABEL_TEAM_LABEL, GITHUB_LABEL_TUTORIAL_LABEL, GITHUB_LABEL_FUNCTIONALITY_BUG, GITHUB_LABEL_MEDIUM_SEVERITY],
+  state: IssueState.Open,
+  stateReason: IssueStateReason.Reopened,
+  title: 'Screen freezes',
+  updated_at: '2020-03-02T12:50:02Z',
+  closed_at: '',
+  url: 'https://api.github.com/repos/CATcher-org/pe-results/issues/91',
+  user: USER_ANUBHAV_DETAILS,
+  milestone: CLOSED_MILESTONE,
+  comments: [EMPTY_TEAM_RESPONSE],
+  issueOrPr: 'Issue',
+  isDraft: false
+});
+
 export const generateIssueWithRandomData: () => GithubIssue = () => {
   const created_and_updated_date: string = randomISODate();
   const issueNumber: number = randomIssueNumber();
diff --git a/tests/constants/milestone.constants.ts b/tests/constants/milestone.constants.ts
new file mode 100644
index 000000000..8e761447c
--- /dev/null
+++ b/tests/constants/milestone.constants.ts
@@ -0,0 +1,27 @@
+export const MILESTONE_WITHOUT_DEADLINE_DATA = {
+  title: 'Milestone Without Deadline',
+  due_on: undefined
+};
+
+export const MILESTONE_WITH_FUTURE_DEADLINE_DATA = {
+  title: 'Milestone With Valid Deadline',
+  due_on: '2026-07-18T08:00:00.000Z'
+};
+
+export const MILESTONE_WITH_PAST_DEADLINE_DATA = {
+  title: 'Milestone With Past Deadline',
+  due_on: '2024-07-18T08:00:00.000Z',
+  state: 'open'
+};
+
+export const ACTIVE_MILESTONE_ONE = {
+  title: 'Milestone 1',
+  due_on: '2026-07-18T08:00:00.000Z',
+  state: 'open'
+};
+
+export const ACTIVE_MILESTONE_TWO = {
+  title: 'Milestone 2',
+  due_on: '2026-07-18T08:00:00.000Z',
+  state: 'open'
+};
diff --git a/tests/services/milestone.service.spec.ts b/tests/services/milestone.service.spec.ts
index 3d25949f8..73283a7b9 100644
--- a/tests/services/milestone.service.spec.ts
+++ b/tests/services/milestone.service.spec.ts
@@ -1,7 +1,18 @@
 import { of } from 'rxjs';
+import { MilestoneAnomaliesStatus } from '../../src/app/core/constants/milestone-anomalies.constants';
+import { Issue } from '../../src/app/core/models/issue.model';
+import { GeneralMilestoneAnomaly, MilestoneAnomaly, SingleMilestoneAnomaly } from '../../src/app/core/models/milestone-anomaly.model';
 import { Milestone } from '../../src/app/core/models/milestone.model';
 import { GithubService } from '../../src/app/core/services/github.service';
 import { MilestoneService } from '../../src/app/core/services/milestone.service';
+import { OPEN_ISSUE_WITH_CLOSED_MILESTONE } from '../constants/githubissue.constants';
+import {
+  ACTIVE_MILESTONE_ONE,
+  ACTIVE_MILESTONE_TWO,
+  MILESTONE_WITHOUT_DEADLINE_DATA,
+  MILESTONE_WITH_FUTURE_DEADLINE_DATA,
+  MILESTONE_WITH_PAST_DEADLINE_DATA
+} from '../constants/milestone.constants';
 
 let milestoneService: MilestoneService;
 let githubServiceSpy: jasmine.SpyObj<GithubService>;
@@ -51,4 +62,72 @@ describe('MilestoneService', () => {
       expect(parsedMilestones[0].title).toBe('Milestone 1');
     });
   });
+
+  describe('MilestoneService: getMilestoneAnomalies()', () => {
+    it('should return milestones with no deadline as anomalies', (done) => {
+      const mockMilestones = [MILESTONE_WITHOUT_DEADLINE_DATA, MILESTONE_WITH_FUTURE_DEADLINE_DATA];
+      githubServiceSpy.fetchAllMilestones.and.returnValue(of(mockMilestones));
+
+      const expectedAnomaly: MilestoneAnomaly = new SingleMilestoneAnomaly(
+        milestoneService.parseMilestoneData([MILESTONE_WITHOUT_DEADLINE_DATA])[0],
+        MilestoneAnomaliesStatus.NoDeadline
+      );
+
+      milestoneService.fetchMilestones().subscribe((response) => {
+        expect(githubServiceSpy.fetchAllMilestones).toHaveBeenCalled();
+        expect(milestoneService.milestones.length).toBe(2);
+        expect(milestoneService.getMilestoneAnomalies()).toEqual([expectedAnomaly]);
+
+        done();
+      });
+    });
+
+    it('should return milestones that have gone past deadline', (done) => {
+      const mockMilestones = [MILESTONE_WITH_PAST_DEADLINE_DATA, MILESTONE_WITH_FUTURE_DEADLINE_DATA];
+      githubServiceSpy.fetchAllMilestones.and.returnValue(of(mockMilestones));
+
+      const expectedAnomaly: MilestoneAnomaly = new SingleMilestoneAnomaly(
+        milestoneService.parseMilestoneData([MILESTONE_WITH_PAST_DEADLINE_DATA])[0],
+        MilestoneAnomaliesStatus.PastDeadline
+      );
+
+      milestoneService.fetchMilestones().subscribe((response) => {
+        expect(githubServiceSpy.fetchAllMilestones).toHaveBeenCalled();
+        expect(milestoneService.milestones.length).toBe(2);
+        expect(milestoneService.getMilestoneAnomalies()).toEqual([expectedAnomaly]);
+
+        done();
+      });
+    });
+
+    it('should detect anomalies for multiple active milestones', (done) => {
+      const mockMilestones = [ACTIVE_MILESTONE_ONE, ACTIVE_MILESTONE_TWO];
+      githubServiceSpy.fetchAllMilestones.and.returnValue(of(mockMilestones));
+
+      const expectedAnomaly: MilestoneAnomaly = new GeneralMilestoneAnomaly(
+        milestoneService.parseMilestoneData(mockMilestones),
+        MilestoneAnomaliesStatus.MultipleOpenMilestoneAnomaly
+      );
+
+      milestoneService.fetchMilestones().subscribe((response) => {
+        expect(githubServiceSpy.fetchAllMilestones).toHaveBeenCalled();
+        expect(milestoneService.milestones.length).toBe(2);
+        expect(milestoneService.getMilestoneAnomalies()).toEqual([expectedAnomaly]);
+
+        done();
+      });
+    });
+  });
+
+  describe('MilestoneService: updateClosedMilestoneWithOpenIssueOrPR(issues: Issue[])', () => {
+    it('should detect anomalies for closed milestones with open issues or unmerged PRs', () => {
+      const issues = Issue.createPhaseBugReportingIssue(OPEN_ISSUE_WITH_CLOSED_MILESTONE);
+      const expectedAnomaly: MilestoneAnomaly = new SingleMilestoneAnomaly(
+        milestoneService.parseMilestoneData([OPEN_ISSUE_WITH_CLOSED_MILESTONE.milestone])[0],
+        MilestoneAnomaliesStatus.ClosedMilestoneAnomaly
+      );
+      milestoneService.updateClosedMilestoneWithOpenIssueOrPR([issues]);
+      expect(milestoneService.getMilestoneAnomalies()).toEqual([expectedAnomaly]);
+    });
+  });
 });