Added unit tests for notification actions

mackdk · mackdk · commit 42b01b631170 · 2024-02-19T17:07:07.000+01:00
diff --git a/src/main/typescript/notifications/actions/MarkAsReadAction.ts b/src/main/typescript/notifications/actions/MarkAsReadAction.ts
@@ -32,11 +32,9 @@ export class MarkAsReadAction implements NotificationAction {
     }
 
     private readSingle(notification: GitHub.Thread): void {
-        this.gitHubClient
-            .markThreadAsRead(notification)
-            .then(() => {
-                return this.eventDispatcher.emit('notificationRead', notification.id);
-            })
+        void Promise.resolve()
+            .then(() => this.gitHubClient.markThreadAsRead(notification))
+            .then(() => this.eventDispatcher.emit('notificationRead', notification.id))
             .catch((error) => {
                 if (error instanceof ApiError) {
                     MarkAsReadAction.LOGGER.error(
@@ -53,11 +51,9 @@ export class MarkAsReadAction implements NotificationAction {
     }
 
     private readAll(): void {
-        this.gitHubClient
-            .markAllThreadsAsRead()
-            .then(() => {
-                return this.eventDispatcher.emit('allNotificationsRead');
-            })
+        void Promise.resolve()
+            .then(() => this.gitHubClient.markAllThreadsAsRead())
+            .then(() => this.eventDispatcher.emit('allNotificationsRead'))
             .catch((error) => {
                 if (error instanceof ApiError) {
                     MarkAsReadAction.LOGGER.error(
diff --git a/src/main/typescript/notifications/actions/OpenAction.ts b/src/main/typescript/notifications/actions/OpenAction.ts
@@ -35,8 +35,8 @@ export class OpenAction implements NotificationAction {
     }
 
     private openSingle(notification: GitHub.Thread): void {
-        this.gitHubClient
-            .getWebUrlForSubject(notification.subject)
+        void Promise.resolve()
+            .then(() => this.gitHubClient.getWebUrlForSubject(notification.subject))
             .then((url) => show_uri(null, url, CURRENT_TIME))
             .then(() => this.eventDispatcher.emit('notificationRead', notification.id))
             .catch((error) => {
diff --git a/src/test/stubs/gi-types/clutter10.ts b/src/test/stubs/gi-types/clutter10.ts
@@ -0,0 +1 @@
+export let CURRENT_TIME: number = new Date().getTime()
diff --git a/src/test/stubs/gi-types/gtk4.ts b/src/test/stubs/gi-types/gtk4.ts
@@ -0,0 +1 @@
+export function show_uri(parent: Window | null, uri: string, timestamp: number): void {}
diff --git a/src/test/stubs/gi-types/st1.ts b/src/test/stubs/gi-types/st1.ts
@@ -0,0 +1,3 @@
+export class Widget {}
+
+export class BoxLayout {}
diff --git a/src/test/stubs/gnome-shell/misc/extensionUtils.ts b/src/test/stubs/gnome-shell/misc/extensionUtils.ts
@@ -1,3 +1,5 @@
+import { Settings } from '@gi-types/gio2';
+
 export class ExtensionMetadata {
     uuid: string = 'e1f0a5eb-a65b-4dff-a0c2-ba024ac7ea3a';
     name: string = 'TestSuite';
@@ -28,3 +30,9 @@ export function getCurrentExtension(): Extension {
     ext.metadata.name = 'TestSuite';
     return ext;
 };
+
+export function openPrefs(): void {};
+
+export function getSettings(name?: string): Settings {
+    return new Settings();
+};
diff --git a/src/test/stubs/gnome-shell/ui/index.ts b/src/test/stubs/gnome-shell/ui/index.ts
@@ -0,0 +1,9 @@
+import { MessageTray } from './ui/messageTray';
+import { Panel } from './ui/panel';
+
+export class Main {
+    panel: Panel = new Panel();
+    messageTray: MessageTray = new MessageTray();
+}
+
+export const main: Main = new Main();
diff --git a/src/test/stubs/gnome-shell/ui/panel.ts b/src/test/stubs/gnome-shell/ui/panel.ts
@@ -0,0 +1,11 @@
+import { BoxLayout } from '@gi-types/st1';
+
+import { Button } from './panelMenu';
+
+export class Panel {
+    _rightBox: BoxLayout = new BoxLayout();
+
+    public addToStatusArea(role: string, indicator: Button, position?: number, box?: number): Button {
+        return new Button();
+    }
+}
diff --git a/src/test/stubs/gnome-shell/ui/panelMenu.ts b/src/test/stubs/gnome-shell/ui/panelMenu.ts
@@ -0,0 +1,12 @@
+import { Widget } from "@gi-types/st1";
+
+export class ButtonBox {}
+
+export class Button extends ButtonBox {
+    
+    public constructor(_menuAlignment?: number, _nameText?: string, _dontCreateMenu?: boolean) {
+        super();
+    }
+
+    public add_actor(widget: Widget): void {}
+}
diff --git a/src/test/typescript/notifications/actions/MarkAsReadAction.test.ts b/src/test/typescript/notifications/actions/MarkAsReadAction.test.ts
@@ -0,0 +1,84 @@
+import { readFileSync } from 'fs';
+
+import { GitHubClientStub, assertWithRetries, testResource } from '@test-suite/testSupport';
+import { assert } from 'chai';
+import { spy, stub } from 'sinon';
+
+import * as GitHub from '@github-manager/client/GitHubApiTypes';
+import { GitHubClient } from '@github-manager/client/GitHubClient';
+import { MarkAsReadAction } from '@github-manager/notifications/actions/MarkAsReadAction';
+import { EventDispatcher } from '@github-manager/utils';
+
+describe('Mark As Read Action', () => {
+    let thread: GitHub.Thread;
+    let action: MarkAsReadAction;
+
+    let githubClient: GitHubClient;
+    let eventDispatcher: EventDispatcher;
+
+    before(() => {
+        const scenarioJSON = readFileSync(testResource('../notifications.json'), { encoding: 'utf-8' });
+        thread = (JSON.parse(scenarioJSON) as GitHub.Thread[])[0];
+    });
+
+    beforeEach(() => {
+        githubClient = new GitHubClientStub();
+        eventDispatcher = new EventDispatcher();
+
+        action = new MarkAsReadAction(githubClient, eventDispatcher);
+    });
+
+    describe('On a single notification', () => {
+        it('can mark it as read', () => {
+            const markThreadAsReadSpy = spy(githubClient, 'markThreadAsRead');
+            const emitSpy = spy(eventDispatcher, 'emit');
+
+            action.execute(thread);
+
+            void assertWithRetries('Notification is correctly marked as read', 10, 150, () => {
+                assert.equal(markThreadAsReadSpy.callCount, 1);
+                assert.equal(markThreadAsReadSpy.firstCall.args.length, 1);
+                assert.equal(markThreadAsReadSpy.firstCall.firstArg, thread);
+
+                assert.equal(emitSpy.callCount, 1);
+                assert.equal(emitSpy.firstCall.args.length, 2);
+                assert.equal(emitSpy.firstCall.args[0], 'notificationRead');
+                assert.equal(emitSpy.firstCall.args[1], thread.id);
+            });
+        });
+
+        it('does nothing if GitHub call fails', () => {
+            const emitSpy = spy(eventDispatcher, 'emit');
+            stub(githubClient, 'markThreadAsRead').throws(new Error('Api Error'));
+
+            assert.doesNotThrow(() => action.execute(thread));
+            assert.isTrue(emitSpy.notCalled);
+        });
+    });
+
+    describe('On all notifications', () => {
+        it('can mark them as read', () => {
+            const markAllThreadsAsReadSpy = spy(githubClient, 'markAllThreadsAsRead');
+            const emitSpy = spy(eventDispatcher, 'emit');
+
+            action.execute();
+
+            void assertWithRetries('All notifications are marked as read', 10, 150, () => {
+                assert.equal(markAllThreadsAsReadSpy.callCount, 1);
+                assert.equal(markAllThreadsAsReadSpy.firstCall.args.length, 0);
+
+                assert.equal(emitSpy.callCount, 1);
+                assert.equal(emitSpy.firstCall.args.length, 1);
+                assert.equal(emitSpy.firstCall.args[0], 'allNotificationsRead');
+            });
+        });
+
+        it('does nothing if GitHub call fails', () => {
+            const emitSpy = spy(eventDispatcher, 'emit');
+            stub(githubClient, 'markAllThreadsAsRead').throws(new Error('Api Error'));
+
+            assert.doesNotThrow(() => action.execute());
+            assert.isTrue(emitSpy.notCalled);
+        });
+    });
+});
diff --git a/src/test/typescript/notifications/actions/OpenAction.test.ts b/src/test/typescript/notifications/actions/OpenAction.test.ts
@@ -0,0 +1,103 @@
+import { readFileSync } from 'fs';
+
+import * as Gtk4 from '@gi-types/gtk4';
+import { GitHubClientStub, assertWithRetries, testResource } from '@test-suite/testSupport';
+import { assert } from 'chai';
+import { SinonSpy, spy, stub } from 'sinon';
+
+import * as GitHub from '@github-manager/client/GitHubApiTypes';
+import { GitHubClient } from '@github-manager/client/GitHubClient';
+import { OpenAction } from '@github-manager/notifications/actions/OpenAction';
+import { EventDispatcher } from '@github-manager/utils/';
+
+describe('Open Action', () => {
+    let thread: GitHub.Thread;
+    let action: OpenAction;
+
+    let githubClient: GitHubClient;
+    let eventDispatcher: EventDispatcher;
+
+    let showUriSpy: SinonSpy<[parent: Window | null, uri: string, timestamp: number], void>;
+
+    before(() => {
+        const scenarioJSON = readFileSync(testResource('../notifications.json'), { encoding: 'utf-8' });
+        thread = (JSON.parse(scenarioJSON) as GitHub.Thread[])[0];
+
+        showUriSpy = spy(Gtk4, 'show_uri');
+    });
+
+    beforeEach(() => {
+        githubClient = new GitHubClientStub();
+        eventDispatcher = new EventDispatcher();
+
+        action = new OpenAction(githubClient, eventDispatcher);
+
+        showUriSpy.resetHistory();
+    });
+
+    after(() => {
+        showUriSpy.restore();
+    });
+
+    describe('On a single notification', () => {
+        it('opens its web page', () => {
+            const getWebUrlStub = stub(githubClient, 'getWebUrlForSubject').returns(
+                Promise.resolve('http://example.com')
+            );
+            const emitSpy = spy(eventDispatcher, 'emit');
+
+            action.execute(thread);
+
+            void assertWithRetries('dependencies correctly called', 10, 150, () => {
+                assert.equal(getWebUrlStub.callCount, 1);
+                assert.equal(getWebUrlStub.firstCall.args.length, 1);
+                assert.equal(getWebUrlStub.firstCall.firstArg, thread.subject);
+
+                assert.equal(showUriSpy.callCount, 1);
+                assert.equal(showUriSpy.firstCall.args.length, 3);
+                assert.isNull(showUriSpy.firstCall.args[0]);
+                assert.equal(showUriSpy.firstCall.args[1], 'http://example.com');
+
+                assert.equal(emitSpy.callCount, 1);
+                assert.equal(emitSpy.firstCall.args.length, 2);
+                assert.equal(emitSpy.firstCall.args[0], 'notificationRead');
+                assert.equal(emitSpy.firstCall.args[1], thread.id);
+            });
+        });
+
+        it('opens notification page when cannot retrieve url', () => {
+            const emitSpy = spy(eventDispatcher, 'emit');
+
+            stub(githubClient, 'getWebUrlForSubject').throws(new Error('API Error'));
+            assert.doesNotThrow(() => action.execute(thread));
+
+            void assertWithRetries('dependencies correctly called', 10, 150, () => {
+                assert.isTrue(emitSpy.notCalled);
+
+                assert.equal(showUriSpy.callCount, 1);
+                assert.equal(showUriSpy.firstCall.args.length, 3);
+                assert.isNull(showUriSpy.firstCall.args[0]);
+                assert.equal(showUriSpy.firstCall.args[1], 'http://stub.domain.com/notifications');
+            });
+        });
+    });
+
+    describe('On all notifications', () => {
+        it('opens notification page', () => {
+            const getWebUrlStub = spy(githubClient, 'getWebUrlForSubject');
+            const emitSpy = spy(eventDispatcher, 'emit');
+
+            action.execute();
+
+            void assertWithRetries('dependencies correctly called', 10, 150, () => {
+                assert.isTrue(getWebUrlStub.notCalled);
+                assert.isTrue(emitSpy.notCalled);
+
+                assert.equal(showUriSpy.callCount, 1);
+                assert.equal(showUriSpy.firstCall.args.length, 3);
+                assert.isNull(showUriSpy.firstCall.args[0]);
+                assert.equal(showUriSpy.firstCall.args[1], 'http://stub.domain.com/notifications');
+            });
+        });
+    });
+});
diff --git a/src/test/typescript/testSupport/index.ts b/src/test/typescript/testSupport/index.ts
@@ -2,6 +2,8 @@ import { dirname, resolve } from 'path';
 
 import callsites from 'callsites';
 
+import * as GitHub from '@github-manager/client/GitHubApiTypes';
+import { GitHubClient } from '@github-manager/client/GitHubClient';
 import { HttpEngine, HttpRequest, HttpResponse } from '@github-manager/client/Http';
 
 // Simple do-nothing HttpEngine implementation
@@ -11,6 +13,29 @@ export class HttpEngineStup implements HttpEngine {
     }
 }
 
+// Simple do-nothing GitHub client implementation
+export class GitHubClientStub implements GitHubClient {
+    public readonly pollInterval: number = 100;
+    public domain: string = 'stub.domain.com';
+    public token: string = 'FakeToken';
+
+    public listThreads(_showParticipatingOnly?: boolean): Promise<GitHub.Thread[]> {
+        return Promise.resolve([]);
+    }
+
+    public markThreadAsRead(_githubNotification: GitHub.Thread): Promise<void> {
+        return Promise.resolve();
+    }
+
+    public markAllThreadsAsRead(_updateDate?: Date): Promise<void> {
+        return Promise.resolve();
+    }
+
+    public getWebUrlForSubject(_subject: GitHub.Subject): Promise<string> {
+        return Promise.resolve('http://example.com');
+    }
+}
+
 // Load a resource for the current test using the same base path within the test/resources path
 export function testResource(filename: string): string {
     const callerFile = callsites()[1].getFileName();
@@ -19,4 +44,24 @@ export function testResource(filename: string): string {
     }
 
     return resolve(dirname(callerFile).replace('test/typescript', 'test/resources'), filename);
-};
+}
+
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function assertWithRetries(name: string, retries: number, delay: number, code: () => void): Promise<void> {
+    let failure: unknown;
+
+    for (let attempt = 0; attempt < retries; attempt++) {
+        try {
+            code();
+            return;
+        } catch (error) {
+            failure = error;
+            await sleep(delay);
+        }
+    }
+
+    throw failure;
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export let CURRENT_TIME: number = new Date().getTime()`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export function show_uri(parent: Window \| null, uri: string, timestamp: number): void {}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+export class Widget {}`
	`2`	`+`
	`3`	`+export class BoxLayout {}`