test: add more tests

Author: pamapa

src/UserManager.test.ts

@@ -11,7 +11,7 @@ import {
 } from "./navigators";
 import type { SigninResponse } from "./SigninResponse";
 import type { SignoutResponse } from "./SignoutResponse";
-import { UserManager, type SigninPopupArgs, type SigninRedirectArgs, type SigninSilentArgs, type SignoutSilentArgs } from "./UserManager";
+import { UserManager, type SigninPopupArgs, type SigninRedirectArgs, type SigninSilentArgs, type SignoutSilentArgs, type SignoutPopupArgs } from "./UserManager";
 import { UserManagerSettingsStore } from "./UserManagerSettings";
 import { User } from "./User";
 import type { UserProfile } from "./User";
@@ -689,7 +689,7 @@ describe("UserManager", () => {
             const url = "http://app/cb?state=test&code=code";
 
             // act
-            await subject.signoutCallback(url, true);
+            await subject.signoutCallback(url);
 
             // assert
             expect(signoutRedirectCallbackMock).toHaveBeenCalledWith(url);
@@ -715,6 +715,38 @@ describe("UserManager", () => {
             expect(signoutPopupCallbackMock).toHaveBeenCalledWith(url, keepOpen);
         });
 
+        it("should signout silent callback for request type so:s", async () => {
+            // arrange
+            const responseState = {
+                state: { request_type: "so:s" } as State,
+                response: { } as SignoutResponse,
+            };
+            jest.spyOn(subject["_client"], "readSignoutResponseState")
+                .mockImplementation(() => Promise.resolve(responseState));
+            const signoutSilentCallbackMock = jest.spyOn(subject, "signoutSilentCallback")
+                .mockImplementation();
+            const url = "http://app/cb?state=test&code=code";
+
+            // act
+            await subject.signoutCallback(url);
+
+            // assert
+            expect(signoutSilentCallbackMock).toHaveBeenCalledWith(url);
+        });
+
+        it("should do nothing without state", async () => {
+            // arrange
+            const responseState = {
+                state: undefined,
+                response: { } as SignoutResponse,
+            };
+            jest.spyOn(subject["_client"], "readSignoutResponseState")
+                .mockImplementation(() => Promise.resolve(responseState));
+
+            // act & assert (no throw)
+            await subject.signoutCallback();
+        });
+
         it("should have valid request type", async () => {
             // arrange
             const responseState = {
@@ -884,6 +916,55 @@ describe("UserManager", () => {
         });
     });
 
+    describe("signoutPopup", () => {
+        it("should pass navigator params to navigator", async () => {
+            // arrange
+            const handle = { } as PopupWindow;
+            const prepareMock = jest.spyOn(subject["_popupNavigator"], "prepare")
+                .mockImplementation(() => Promise.resolve(handle));
+            subject["_signout"] = jest.fn();
+            const navParams: SignoutPopupArgs = {
+                popupWindowFeatures: {
+                    location: false,
+                    toolbar: false,
+                    height: 100,
+                },
+                popupWindowTarget: "popupWindowTarget",
+            };
+
+            // act
+            await subject.signoutPopup(navParams);
+
+            // assert
+            expect(prepareMock).toHaveBeenCalledWith(navParams);
+        });
+
+        it("should pass extra args to _signoutStart", async () => {
+            // arrange
+            const handle = { } as PopupWindow;
+            jest.spyOn(subject["_popupNavigator"], "prepare")
+                .mockImplementation(() => Promise.resolve(handle));
+            subject["_signout"] = jest.fn().mockResolvedValue({} as SignoutResponse);
+            const extraArgs: SignoutPopupArgs = {
+                extraQueryParams: { q : "q" },
+                state: "state",
+                post_logout_redirect_uri: "http://app/extra_callback",
+            };
+
+            // act
+            await subject.signoutPopup(extraArgs);
+
+            // assert
+            expect(subject["_signout"]).toHaveBeenCalledWith(
+                {
+                    request_type: "so:p",
+                    ...extraArgs,
+                },
+                handle,
+            );
+        });
+    });
+
     describe("storeUser", () => {
         it("should add user to store", async () => {
             // arrange

src/UserManagerEvents.test.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
 
+import type { User } from "./User";
 import { UserManagerEvents } from "./UserManagerEvents";
 import { UserManagerSettingsStore } from "./UserManagerSettings";
 
@@ -17,9 +18,78 @@ describe("UserManagerEvents", () => {
         subject = new UserManagerEvents(settings);
     });
 
-    describe("silent renew error", () => {
+    describe("user loaded", () => {
+        it("should allow add callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserLoaded(cb);
+            await subject.load({} as User);
+
+            // assert
+            expect(cb).toHaveBeenCalled();
+        });
+
+        it("should allow remove callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserLoaded(cb);
+            subject.removeUserLoaded(cb);
+            await subject.load({} as User);
+
+            // assert
+            expect(cb).toHaveBeenCalledTimes(0);
+        });
+
+        it("should pass user to callback", async () => {
+            // arrange
+            let u: User | null = null;
+            const cb = function (arg_user: User) {
+                u = arg_user;
+            };
+            const expected = { access_token: "token" } as User;
+
+            // act
+            subject.addUserLoaded(cb);
+            await subject.load(expected);
+
+            // assert
+            expect(u).toEqual(expected);
+        });
+    });
+
+    describe("user unloaded", () => {
+        it("should allow add callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserUnloaded(cb);
+            await subject.unload();
+
+            // assert
+            expect(cb).toHaveBeenCalled();
+        });
+
+        it("should allow remove callback", async () => {
+            // arrange
+            const cb = jest.fn();
 
-        it("should allow callback", async () => {
+            // act
+            subject.addUserUnloaded(cb);
+            subject.removeUserUnloaded(cb);
+            await subject.unload();
+
+            // assert
+            expect(cb).toHaveBeenCalledTimes(0);
+        });
+    });
+
+    describe("silent renew error", () => {
+        it("should allow add callback", async () => {
             // arrange
             const cb = jest.fn();
 
@@ -31,7 +101,7 @@ describe("UserManagerEvents", () => {
             expect(cb).toHaveBeenCalled();
         });
 
-        it("should allow unregistering callback", async () => {
+        it("should allow remove callback", async () => {
             // arrange
             const cb = jest.fn();
 
@@ -60,4 +130,85 @@ describe("UserManagerEvents", () => {
             expect(e).toEqual(expected);
         });
     });
+
+    describe("user signed in", () => {
+        it("should allow add callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserSignedIn(cb);
+            await subject._raiseUserSignedIn();
+
+            // assert
+            expect(cb).toHaveBeenCalled();
+        });
+
+        it("should allow remove callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserSignedIn(cb);
+            subject.removeUserSignedIn(cb);
+            await subject._raiseUserSignedIn();
+
+            // assert
+            expect(cb).toHaveBeenCalledTimes(0);
+        });
+    });
+
+    describe("user signed out", () => {
+        it("should allow add callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserSignedOut(cb);
+            await subject._raiseUserSignedOut();
+
+            // assert
+            expect(cb).toHaveBeenCalled();
+        });
+
+        it("should allow remove callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserSignedOut(cb);
+            subject.removeUserSignedOut(cb);
+            await subject._raiseUserSignedOut();
+
+            // assert
+            expect(cb).toHaveBeenCalledTimes(0);
+        });
+    });
+
+    describe("user session changed", () => {
+        it("should allow add callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserSessionChanged(cb);
+            await subject._raiseUserSessionChanged();
+
+            // assert
+            expect(cb).toHaveBeenCalled();
+        });
+
+        it("should allow remove callback", async () => {
+            // arrange
+            const cb = jest.fn();
+
+            // act
+            subject.addUserSessionChanged(cb);
+            subject.removeUserSessionChanged(cb);
+            await subject._raiseUserSessionChanged();
+
+            // assert
+            expect(cb).toHaveBeenCalledTimes(0);
+        });
+    });
 });