diff --git a/README.md b/README.md
index 37831b9..2950a52 100644
--- a/README.md
+++ b/README.md
@@ -51,6 +51,11 @@ docker-compose run node yarn test:unit
 docker-compose run node yarn lint
 ```
 
+### Show build log
+```
+docker-compose logs -f node
+```
+
 ## Contributing
 
 You are welcome to contribute to SoftDocLinker if you have improvements or bug fixes.
diff --git a/src/App.vue b/src/App.vue
index 79a81a7..6dec89a 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -1,5 +1,9 @@
 <template>
     <v-app id="softdoclinker-app">
+        <!-- Notification management -->
+        <notifications-component />
+
+        <!-- Drawer for documentation view  -->
         <v-navigation-drawer
             :clipped="$vuetify.breakpoint.lgAndUp"
             v-model="drawer"
@@ -10,6 +14,7 @@
 
         <navigation-component :drawer="drawer" @toggleDrawer="toggleDrawer" />
 
+        <!-- Content area for loaded documentation -->
         <v-content>
             <v-container class="fill-height" fluid>
                 <v-row align="center" justify="center" />
@@ -22,6 +27,7 @@
 <script lang="ts">
 import NavigationComponent from "@/components/NavigationComponent.vue";
 import RefreshDataComponent from "@/components/RefreshDataComponent.vue";
+import NotificationsComponent from "@/components/NotificationsComponent.vue";
 import defaultSharedState from "@/model/defaultSharedState";
 import SharedStateInterface from "@/model/SharedStateInterface";
 import StateManagementInterface from "@/model/StateManagementInterface";
@@ -31,7 +37,8 @@ export default Vue.extend({
     name: "App",
     components: {
         NavigationComponent,
-        RefreshDataComponent
+        RefreshDataComponent,
+        NotificationsComponent
     },
     data: function() {
         return {
diff --git a/src/SoftDocLinker.ts b/src/SoftDocLinker.ts
index 5cf5d78..129991a 100755
--- a/src/SoftDocLinker.ts
+++ b/src/SoftDocLinker.ts
@@ -11,6 +11,8 @@ import DocCollectionInterface from "@/model/doc/DocCollectionInterface";
 import StateManagementFactory from "@/model/StateManagementFactory";
 import StateManagementInterface from "@/model/StateManagementInterface";
 import SoftDocLinkerInterface from "@/SoftDocLinkerInterface";
+import NotificationManagementInterface from "@/service/notification/NotificationManagementInterface";
+import NotificationManagementFactory from "@/service/notification/NotificationManagementFactory";
 import Vue from "vue";
 
 /**
@@ -77,6 +79,11 @@ export class SoftDocLinker implements SoftDocLinkerInterface {
      */
     protected _stateManagement?: StateManagementInterface;
 
+    /**
+     * Manager for notifications that are currently displayed
+     */
+    protected _notificationManagement: NotificationManagementInterface;
+
     /**
      * Constructor
      *
@@ -93,7 +100,8 @@ export class SoftDocLinker implements SoftDocLinkerInterface {
         cacheManagementFactory: CacheManagementFactory = new CacheManagementFactory(),
         docCollectionDataProviderFactory: DocCollectionDataProviderFactory = new DocCollectionDataProviderFactory(),
         docCollectionDataRepositoryFactory: DocCollectionDataRepositoryFactory = new DocCollectionDataRepositoryFactory(),
-        stateManagementFactory: StateManagementFactory = new StateManagementFactory()
+        stateManagementFactory: StateManagementFactory = new StateManagementFactory(),
+        notificationManagement: NotificationManagementInterface = new NotificationManagementFactory().create()
     ) {
         this._configDataProviderFactory = configDataProviderFactory;
         this._configDataRepositoryFactory = configDataRepositoryFactory;
@@ -102,6 +110,7 @@ export class SoftDocLinker implements SoftDocLinkerInterface {
         this._docCollectionDataProviderFactory = docCollectionDataProviderFactory;
         this._docCollectionDataRepositoryFactory = docCollectionDataRepositoryFactory;
         this._stateManagementFactory = stateManagementFactory;
+        this._notificationManagement = notificationManagement;
     }
 
     /**
@@ -161,9 +170,23 @@ export class SoftDocLinker implements SoftDocLinkerInterface {
         this._stateManagement = this._stateManagementFactory.create(
             await this.getConfigDataRepository(),
             await this.getDocCollectionDataRepository(),
+            this.notificationManagement,
             Vue.prototype.$sharedState
         );
 
         return this._stateManagement;
     }
+
+    /**
+     * Getter: _notificationManagement.
+     *
+     * Get the notification management instance used to manage the
+     * the current notifications.
+     *
+     * @inheritdoc
+     */
+    /* istanbul ignore next */
+    public get notificationManagement(): NotificationManagementInterface {
+        return this._notificationManagement;
+    }
 }
diff --git a/src/SoftDocLinkerInterface.ts b/src/SoftDocLinkerInterface.ts
index 44528fa..d23f6aa 100755
--- a/src/SoftDocLinkerInterface.ts
+++ b/src/SoftDocLinkerInterface.ts
@@ -2,6 +2,7 @@ import ConfigDataInterface from "@/model/config/ConfigDataInterface";
 import DataRepositoryInterface from "@/model/DataRepositoryInterface";
 import DocCollectionInterface from "@/model/doc/DocCollectionInterface";
 import StateManagementInterface from "@/model/StateManagementInterface";
+import NotificationManagementInterface from "@/service/notification/NotificationManagementInterface";
 
 /**
  * Defines the interface between our Vue components and
@@ -37,4 +38,12 @@ export default interface SoftDocLinkerInterface {
      * the sharing of the applications state.
      */
     getStateManagement(): Promise<StateManagementInterface>;
+
+    /**
+     * Get the notification management that is currently used by SoftDocLinker to
+     * handle the shown notifications.
+     *
+     * Should be implemented using a get accessor in implementations.
+     */
+    readonly notificationManagement: NotificationManagementInterface;
 }
diff --git a/src/components/NotificationsComponent.vue b/src/components/NotificationsComponent.vue
new file mode 100755
index 0000000..7bebd49
--- /dev/null
+++ b/src/components/NotificationsComponent.vue
@@ -0,0 +1,58 @@
+<template>
+    <div>
+        <v-snackbar
+            v-for="notification in notifications"
+            :key="notification.id"
+            :bottom="true"
+            v-model="notification.show"
+        >
+            {{ notification.type }}: {{ notification.message }}
+            <v-btn
+                color="blue"
+                text
+                @click="submitCloseNotification(notification)"
+            >
+                Close
+            </v-btn>
+        </v-snackbar>
+    </div>
+</template>
+
+<script lang="ts">
+import NotificationInterface from "@/model/notification/NotificationInterface";
+import { Component, Vue } from "vue-property-decorator";
+
+/**
+ * Component that handles notification display by making use of the
+ * Vuetify Snackbar component
+ *
+ * @since 2.0.0
+ */
+@Component({
+    name: "NotificationsComponent"
+})
+export default class NotificationsComponent extends Vue {
+    /**
+     * A computed property that provides the notifications array
+     * that provides all notifications that should be created by this component.
+     *
+     * @returns The (reactive) array that contains all visible notifications
+     */
+    get notifications(): NotificationInterface[] {
+        return this.$softDocLinker.notificationManagement.notifications;
+    }
+
+    /**
+     * Called when a notification is being closed manually by clicking
+     * on the close button.
+     *
+     * @param notification The notification of which a close was triggered
+     */
+    private submitCloseNotification(notification: NotificationInterface): void {
+        notification.show = false;
+        this.$softDocLinker.notificationManagement.removeNotification(
+            notification
+        );
+    }
+}
+</script>
diff --git a/src/main.ts b/src/main.ts
index 32ddb47..5a0436e 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -8,7 +8,7 @@ import defaultSharedState from "./model/defaultSharedState";
 
 // Set instance of data layer management with initial default values
 Vue.prototype.$softDocLinker = new SoftDocLinker();
-// Inilize shared state with default value
+// Initialize shared state with default value
 Vue.prototype.$sharedState = Vue.observable(defaultSharedState());
 
 new Vue({
diff --git a/src/model/AbstractDataRepository.ts b/src/model/AbstractDataRepository.ts
index 9f95aaf..6a12128 100755
--- a/src/model/AbstractDataRepository.ts
+++ b/src/model/AbstractDataRepository.ts
@@ -4,7 +4,7 @@ import DataProviderInterface from "@/dataprovider/DataProviderInterface";
 import DataRepositoryInterface from "@/model/DataRepositoryInterface";
 
 /**
- * Abstract data repository that can be implemented get
+ * Abstract data repository that can be implemented to get
  * data from a DataProviderInterface while using caching
  * mechanisms to improve performance.
  *
diff --git a/src/model/StateManagement.ts b/src/model/StateManagement.ts
index 2b37fc1..29c1729 100755
--- a/src/model/StateManagement.ts
+++ b/src/model/StateManagement.ts
@@ -1,11 +1,14 @@
 import ConfigDataInterface from "@/model/config/ConfigDataInterface";
+import ConfigDataRepository from "@/model/config/ConfigDataRepository";
 import DataRepositoryInterface from "@/model/DataRepositoryInterface";
 import defaultSharedState from "@/model/defaultSharedState";
+import DocCollectionDataRepository from "@/model/doc/DocCollectionDataRepository";
+import DocCollectionInterface from "@/model/doc/DocCollectionInterface";
+import NotificationFactory from "@/model/notification/NotificationFactory";
+import NotificationType from "@/model/notification/NotificationType";
 import SharedStateInterface from "@/model/SharedStateInterface";
 import StateManagementInterface from "@/model/StateManagementInterface";
-import DocCollectionInterface from "@/model/doc/DocCollectionInterface";
-import ConfigDataRepository from "@/model/config/ConfigDataRepository";
-import DocCollectionDataRepository from "@/model/doc/DocCollectionDataRepository";
+import NotificationManagementInterface from "@/service/notification/NotificationManagementInterface";
 
 /**
  * State management that manages the data used by the rendering.
@@ -27,6 +30,16 @@ export default class StateManagement implements StateManagementInterface {
         DocCollectionInterface
     >;
 
+    /**
+     * The notification management used to display notifications to the user
+     */
+    protected _notificationManagement: NotificationManagementInterface;
+
+    /**
+     * Factory used to build notifications.
+     */
+    protected _notificationFactory: NotificationFactory;
+
     /**
      * The shared state of SoftDocLinker
      */
@@ -42,10 +55,14 @@ export default class StateManagement implements StateManagementInterface {
     constructor(
         configDataRepository: DataRepositoryInterface<ConfigDataInterface>,
         docDataRepository: DataRepositoryInterface<DocCollectionInterface>,
+        notificationManagement: NotificationManagementInterface,
+        notificationFactory: NotificationFactory = new NotificationFactory(),
         sharedState: SharedStateInterface = defaultSharedState()
     ) {
         this._configDataRepository = configDataRepository;
         this._docDataRepository = docDataRepository;
+        this._notificationManagement = notificationManagement;
+        this._notificationFactory = notificationFactory;
         this._sharedState = sharedState;
     }
 
@@ -66,7 +83,12 @@ export default class StateManagement implements StateManagementInterface {
                 forceRefresh
             );
         } catch (error) {
-            throw error;
+            this._notificationManagement.notify(
+                this._notificationFactory.create(
+                    "Failed to refresh data!",
+                    NotificationType.ERROR
+                )
+            );
         } finally {
             this._sharedState.loading = false;
         }
diff --git a/src/model/StateManagementFactory.ts b/src/model/StateManagementFactory.ts
index 156fabe..4354651 100755
--- a/src/model/StateManagementFactory.ts
+++ b/src/model/StateManagementFactory.ts
@@ -7,6 +7,8 @@ import StateManagement from "@/model/StateManagement";
 import StateManagementInterface from "@/model/StateManagementInterface";
 import SharedStateInterface from "@/model/SharedStateInterface";
 import defaultSharedState from "@/model/defaultSharedState";
+import NotificationManagementInterface from "@/service/notification/NotificationManagementInterface";
+import NotificationFactory from "./notification/NotificationFactory";
 
 export default class StateManagementFactory {
     public create(
@@ -14,11 +16,14 @@ export default class StateManagementFactory {
         docCollectionRepository: DataRepositoryInterface<
             DocCollectionInterface
         >,
+        notificationManagement: NotificationManagementInterface,
         sharedState: SharedStateInterface = defaultSharedState()
     ): StateManagementInterface {
         return new StateManagement(
             configDataRepository,
             docCollectionRepository,
+            notificationManagement,
+            new NotificationFactory(),
             sharedState
         );
     }
diff --git a/src/model/notification/NotificationFactory.ts b/src/model/notification/NotificationFactory.ts
new file mode 100755
index 0000000..b1388b6
--- /dev/null
+++ b/src/model/notification/NotificationFactory.ts
@@ -0,0 +1,25 @@
+/* istanbul ignore file */
+
+import NotificationInterface from "./NotificationInterface";
+
+/**
+ * Factory to create notifications.
+ *
+ * @since 2.0.0
+ */
+export default class NotificationFactory {
+    /**
+     * Create a new notification.
+     *
+     * @param type The type of the notification to create
+     * @param message The message of the notification
+     * @returns A new notification with the given data
+     */
+    public create(type: string, message: string): NotificationInterface {
+        return {
+            type: type,
+            message: message,
+            show: false
+        };
+    }
+}
diff --git a/src/model/notification/NotificationInterface.ts b/src/model/notification/NotificationInterface.ts
new file mode 100755
index 0000000..994eae0
--- /dev/null
+++ b/src/model/notification/NotificationInterface.ts
@@ -0,0 +1,25 @@
+/* istanbul ignore file */
+
+/**
+ * Model of the data required to display a notification.
+ *
+ * @since 2.0.0
+ */
+export default interface NotificationInterface {
+    /**
+     * The message that is displayed by the notification.
+     */
+    message: string;
+
+    /**
+     * The type the displayed notification should have
+     *
+     * @see ./NotificationType
+     */
+    type: string;
+
+    /**
+     * State of this notification should be shown in the frontend.
+     */
+    show: boolean;
+}
diff --git a/src/model/notification/NotificationType.ts b/src/model/notification/NotificationType.ts
new file mode 100755
index 0000000..5e40150
--- /dev/null
+++ b/src/model/notification/NotificationType.ts
@@ -0,0 +1,24 @@
+/* istanbul ignore file */
+
+/**
+ * Notification type that provides different types for notifications
+ * to categorize them.
+ *
+ * @since 2.0.0
+ */
+export default class NotificationType {
+    /**
+     * Notification level: INFO
+     */
+    public static readonly INFO = "INFO";
+
+    /**
+     * Notification level: SUCCESS
+     */
+    public static readonly SUCCESS = "SUCCESS";
+
+    /**
+     * Notification level: ERROR
+     */
+    public static readonly ERROR = "ERROR";
+}
diff --git a/src/service/notification/NotificationManagement.ts b/src/service/notification/NotificationManagement.ts
new file mode 100755
index 0000000..b5538aa
--- /dev/null
+++ b/src/service/notification/NotificationManagement.ts
@@ -0,0 +1,106 @@
+import NotificationManagementInterface from "@/service/notification/NotificationManagementInterface";
+import NotificationInterface from "@/model/notification/NotificationInterface";
+import Vue from "vue";
+
+/**
+ * Simple notification management that is used to add and remove
+ * available notifications.
+ *
+ * @since 2.0.0
+ * @see ./NotificationManagementInterface
+ */
+export default class NotificationManagement
+    implements NotificationManagementInterface {
+    /**
+     * @inheritdoc
+     */
+    protected _notifications: NotificationInterface[] = Vue.observable([]);
+
+    /**
+     * The timeout how long a single notification is shown.
+     */
+    protected timeout: number;
+
+    /**
+     * Constructor
+     *
+     * @param timeout The timeout how long a single notification is shown.
+     */
+    constructor(timeout: number = 3000) {
+        this.timeout = timeout;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public notify(notification: NotificationInterface): boolean {
+        this._notifications.push(notification);
+        notification.show = true;
+        setTimeout(() => {
+            notification.show = false;
+            this.removeNotification(notification);
+        }, this.timeout);
+
+        return true;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public removeNotification(notification: NotificationInterface): boolean {
+        const firstIndex = this._notifications.findIndex(
+            element => element === notification
+        );
+
+        if (firstIndex === -1) {
+            return false;
+        }
+
+        this.removeNotificationByIndex(firstIndex);
+
+        return true;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public removeAllNotifications(
+        notification: NotificationInterface
+    ): boolean {
+        let atLeastRemovedOne = false;
+        let currentIndex;
+        while (
+            (currentIndex = this._notifications.findIndex(element => {
+                return element === notification;
+            })) !== -1
+        ) {
+            this.removeNotificationByIndex(currentIndex);
+            atLeastRemovedOne = true;
+        }
+        atLeastRemovedOne;
+        return atLeastRemovedOne;
+    }
+
+    /**
+     * Remove a single element from the notifications by its index.
+     *
+     * @param index The index of the element to remove
+     */
+    protected removeNotificationByIndex(index: number): void {
+        this._notifications.splice(index, 1);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public purge(): void {
+        this._notifications.splice(0, this._notifications.length);
+    }
+
+    /**
+     * Getter: _notifications
+     */
+    public get notifications(): NotificationInterface[] {
+        return this._notifications;
+    }
+}
diff --git a/src/service/notification/NotificationManagementFactory.ts b/src/service/notification/NotificationManagementFactory.ts
new file mode 100755
index 0000000..cca03a8
--- /dev/null
+++ b/src/service/notification/NotificationManagementFactory.ts
@@ -0,0 +1,20 @@
+/* istanbul ignore file */
+
+import NotificationManagementInterface from "./NotificationManagementInterface";
+import NotificationManagement from "./NotificationManagement";
+
+/**
+ * Factory to create instances that implement the NotificationManagementInterface.
+ *
+ * @since 2.0.0
+ */
+export default class NotificationManagementFactory {
+    /***
+     * Create a new notification management instance.
+     *
+     * @returns a newly created instance that implements NotificationManagementInterface
+     */
+    public create(): NotificationManagementInterface {
+        return new NotificationManagement();
+    }
+}
diff --git a/src/service/notification/NotificationManagementInterface.ts b/src/service/notification/NotificationManagementInterface.ts
new file mode 100755
index 0000000..7b39583
--- /dev/null
+++ b/src/service/notification/NotificationManagementInterface.ts
@@ -0,0 +1,46 @@
+import NotificationInterface from "@/model/notification/NotificationInterface";
+
+/**
+ * Manage the currently available notifications.
+ * This includes:
+ *  - adding new notifications
+ *  - removing existing notifications
+ *  - purging all notifications
+ *
+ * @since 2.0.0
+ */
+export default interface NotificationManagementInterface {
+    /**
+     * The currently available notifications
+     */
+    readonly notifications: NotificationInterface[];
+
+    /**
+     * Play out a new notification that should be displayed.
+     *
+     * @param notification The notification to add
+     * @returns The state if the notification has ben successfully added
+     */
+    notify(notification: NotificationInterface): boolean;
+
+    /**
+     * Remove a notification from the available notifications.
+     * If the same notification object is multiple times in the notifications,
+     * the first one that has been added will be removed.
+     *
+     * @returns A boolean that indicates if the given notification could be removed.
+     */
+    removeNotification(notification: NotificationInterface): boolean;
+
+    /**
+     * Remove all notifications of the same notification object from the available notifications.
+     *
+     * @returns A boolean that indicates if the given notification(s) could be removed.
+     */
+    removeAllNotifications(notification: NotificationInterface): boolean;
+
+    /**
+     * Purge all currently displayed notifications
+     */
+    purge(): void;
+}
diff --git a/tests/unit/SoftDocLinker.spec.ts b/tests/unit/SoftDocLinker.spec.ts
index 21bd8ae..5bdf4c4 100755
--- a/tests/unit/SoftDocLinker.spec.ts
+++ b/tests/unit/SoftDocLinker.spec.ts
@@ -18,6 +18,8 @@ import StateManagementFactory from "@/model/StateManagementFactory";
 import DocCollectionDataRepository from "@/model/doc/DocCollectionDataRepository";
 import DocAjaxDataProvider from "@/dataprovider/doc/DocAjaxDataProvider";
 import StateManagement from "@/model/StateManagement";
+import NotificationManagement from "@/service/notification/NotificationManagement";
+import NotificationManagementInterface from "@/service/notification/NotificationManagementInterface";
 
 jest.mock("@/dataprovider/config/ConfigDataProviderFactory");
 jest.mock("@/cache/CacheDataStorageFactory");
@@ -33,6 +35,7 @@ jest.mock("@/dataprovider/config/ConfigAjaxDataProvider");
 jest.mock("@/dataprovider/doc/DocAjaxDataProvider");
 jest.mock("@/cache/indexeddb/IndexedDBCacheManagement");
 jest.mock("@/model/StateManagementFactory");
+jest.mock("@/service/notification/NotificationManagement");
 
 describe("SoftDocLinker", () => {
     describe("getConfigDataRepository", () => {
@@ -233,10 +236,12 @@ describe("SoftDocLinker", () => {
                 docCacheManagement,
                 cacheDataStorageFactory
             );
+            const notificationManagementMock: NotificationManagementInterface = new NotificationManagement();
 
             const stateManagement: StateManagement = new StateManagement(
                 configDataRepository,
-                docCollectionDataRepository
+                docCollectionDataRepository,
+                notificationManagementMock
             );
             const stateManagementFactory: StateManagementFactory = new StateManagementFactory();
             stateManagementFactory.create = jest.fn(() => {
diff --git a/tests/unit/model/StateManagement.spec.ts b/tests/unit/model/StateManagement.spec.ts
index 8cae736..7937e3d 100755
--- a/tests/unit/model/StateManagement.spec.ts
+++ b/tests/unit/model/StateManagement.spec.ts
@@ -8,11 +8,13 @@ import CacheDataStorageFactory from "@/cache/CacheDataStorageFactory";
 import DocCollectionDataRepository from "@/model/doc/DocCollectionDataRepository";
 import DocAjaxDataProvider from "@/dataprovider/doc/DocAjaxDataProvider";
 import DocCollectionInterface from "@/model/doc/DocCollectionInterface";
+import NotificationManagement from "@/service/notification/NotificationManagement";
 
 jest.mock("@/model/config/ConfigDataRepository");
 jest.mock("@/dataprovider/config/ConfigAjaxDataProvider");
 jest.mock("@/cache/CacheDataStorageFactory");
 jest.mock("@/model/doc/DocCollectionDataRepository");
+jest.mock("@/service/notification/NotificationManagement");
 
 describe("StateManagement", () => {
     describe("update", () => {
@@ -74,9 +76,12 @@ describe("StateManagement", () => {
                     );
                 });
 
+            const notificationManagementMock: NotificationManagement = new NotificationManagement();
+
             const stateManagement: StateManagement = new StateManagement(
                 configDataRepositoryMock,
-                docCollectionDataRepositoryMock
+                docCollectionDataRepositoryMock,
+                notificationManagementMock
             );
 
             try {
@@ -162,10 +167,12 @@ describe("StateManagement", () => {
                         )
                     );
                 });
+            const notificationManagementMock: NotificationManagement = new NotificationManagement();
 
             const stateManagement: StateManagement = new StateManagement(
                 configDataRepositoryMock,
-                docCollectionDataRepositoryMock
+                docCollectionDataRepositoryMock,
+                notificationManagementMock
             );
 
             try {
diff --git a/tests/unit/service/notification/NotificationManagement.spec.ts b/tests/unit/service/notification/NotificationManagement.spec.ts
new file mode 100755
index 0000000..bccd7c5
--- /dev/null
+++ b/tests/unit/service/notification/NotificationManagement.spec.ts
@@ -0,0 +1,152 @@
+import NotificationManagement from "@/service/notification/NotificationManagement";
+import NotificationInterface from "@/model/notification/NotificationInterface";
+import NotificationType from "@/model/notification/NotificationType";
+
+describe("NotificationManagement", () => {
+    describe("notify", () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+        });
+
+        it("should add a notification", () => {
+            const expectedTimeout = 1500;
+
+            const notificationMock: NotificationInterface = {
+                type: NotificationType.INFO,
+                message: "Test",
+                show: false
+            };
+
+            const notificationManagement: NotificationManagement = new NotificationManagement(
+                expectedTimeout
+            );
+            notificationManagement.removeNotification = jest.fn();
+
+            expect(notificationManagement.notifications.length).toBe(0);
+
+            const result = notificationManagement.notify(notificationMock);
+
+            expect(result).toBe(true);
+            expect(notificationManagement.notifications.length).toBeGreaterThan(
+                0
+            );
+            expect(notificationManagement.notifications[0]).toEqual(
+                notificationMock
+            );
+
+            expect(notificationMock.show).toBe(true);
+            expect(
+                notificationManagement.removeNotification
+            ).toHaveBeenCalledTimes(0);
+
+            jest.runAllTimers();
+            expect(setTimeout).toHaveBeenCalled();
+            expect(setTimeout).toHaveBeenCalledWith(
+                expect.any(Function),
+                expectedTimeout
+            );
+
+            expect(notificationMock.show).toBe(false);
+            expect(
+                notificationManagement.removeNotification
+            ).toHaveBeenCalled();
+        });
+    });
+
+    describe("removeNotification", () => {
+        it("should remove exactly one of the specified notification from the notifications", () => {
+            const notificationMock: NotificationInterface = {
+                type: NotificationType.INFO,
+                message: "Test",
+                show: false
+            };
+
+            const notificationManagement: NotificationManagement = new NotificationManagement();
+            for (let i = 0; i < 10; i++) {
+                notificationManagement.notifications.push(notificationMock);
+            }
+
+            const result = notificationManagement.removeNotification(
+                notificationMock
+            );
+
+            expect(result).toBe(true);
+            expect(notificationManagement.notifications.length).toBe(9);
+        });
+
+        it("should return false if there is not notification qual to the specified", () => {
+            const notificationMock: NotificationInterface = {
+                type: NotificationType.INFO,
+                message: "Test",
+                show: false
+            };
+
+            const notificationManagement: NotificationManagement = new NotificationManagement();
+
+            const result = notificationManagement.removeNotification(
+                notificationMock
+            );
+
+            expect(result).toBe(false);
+            expect(notificationManagement.notifications.length).toBe(0);
+        });
+    });
+
+    describe("removeAllNotifications", () => {
+        it("should remove exactly one of the specified notification from the notifications", () => {
+            const notificationMock: NotificationInterface = {
+                type: NotificationType.INFO,
+                message: "Test",
+                show: false
+            };
+
+            const notificationManagement: NotificationManagement = new NotificationManagement();
+            for (let i = 0; i < 10; i++) {
+                notificationManagement.notifications.push(notificationMock);
+            }
+
+            const result = notificationManagement.removeAllNotifications(
+                notificationMock
+            );
+
+            expect(result).toBe(true);
+            expect(notificationManagement.notifications.length).toBe(0);
+        });
+
+        it("should return false if there is not notification qual to the specified", () => {
+            const notificationMock: NotificationInterface = {
+                type: NotificationType.INFO,
+                message: "Test",
+                show: false
+            };
+
+            const notificationManagement: NotificationManagement = new NotificationManagement();
+
+            const result = notificationManagement.removeAllNotifications(
+                notificationMock
+            );
+
+            expect(result).toBe(false);
+            expect(notificationManagement.notifications.length).toBe(0);
+        });
+    });
+
+    describe("purge", () => {
+        it("should clear up all notifications", () => {
+            const notificationMock: NotificationInterface = {
+                type: NotificationType.INFO,
+                message: "Test",
+                show: false
+            };
+
+            const notificationManagement: NotificationManagement = new NotificationManagement();
+            for (let i = 0; i < 10; i++) {
+                notificationManagement.notifications.push(notificationMock);
+            }
+
+            notificationManagement.purge();
+
+            expect(notificationManagement.notifications.length).toBe(0);
+        });
+    });
+});