ASRouterNewTabHook.test.js (6385B)
1 /*eslint max-nested-callbacks: ["error", 10]*/ 2 import { ASRouterNewTabHook } from "modules/ASRouterNewTabHook.sys.mjs"; 3 4 describe("ASRouterNewTabHook", () => { 5 let sandbox = null; 6 let initParams = null; 7 beforeEach(() => { 8 sandbox = sinon.createSandbox(); 9 initParams = { 10 router: { 11 init: sandbox.stub().callsFake(() => { 12 // Fake the initialization 13 initParams.router.initialized = true; 14 }), 15 uninit: sandbox.stub(), 16 }, 17 messageHandler: { 18 handleCFRAction: {}, 19 handleTelemetry: {}, 20 }, 21 createStorage: () => Promise.resolve({}), 22 }; 23 }); 24 afterEach(() => { 25 sandbox.restore(); 26 }); 27 describe("ASRouterNewTabHook", () => { 28 describe("getInstance", () => { 29 it("awaits createInstance and router init before returning instance", async () => { 30 const getInstanceCall = sandbox.spy(); 31 const waitForInstance = 32 ASRouterNewTabHook.getInstance().then(getInstanceCall); 33 await ASRouterNewTabHook.createInstance(initParams); 34 await waitForInstance; 35 assert.callOrder(initParams.router.init, getInstanceCall); 36 }); 37 }); 38 describe("createInstance", () => { 39 it("calls router init", async () => { 40 await ASRouterNewTabHook.createInstance(initParams); 41 assert.calledOnce(initParams.router.init); 42 }); 43 it("only calls router init once", async () => { 44 initParams.router.init.callsFake(() => { 45 initParams.router.initialized = true; 46 }); 47 await ASRouterNewTabHook.createInstance(initParams); 48 await ASRouterNewTabHook.createInstance(initParams); 49 assert.calledOnce(initParams.router.init); 50 }); 51 }); 52 describe("destroy", () => { 53 it("disconnects new tab, uninits ASRouter, and destroys instance", async () => { 54 await ASRouterNewTabHook.createInstance(initParams); 55 const instance = await ASRouterNewTabHook.getInstance(); 56 const destroy = instance.destroy.bind(instance); 57 sandbox.stub(instance, "destroy").callsFake(destroy); 58 ASRouterNewTabHook.destroy(); 59 assert.calledOnce(initParams.router.uninit); 60 assert.calledOnce(instance.destroy); 61 assert.isNotNull(instance); 62 assert.isNull(instance._newTabMessageHandler); 63 }); 64 }); 65 describe("instance", () => { 66 let routerParams = null; 67 let messageHandler = null; 68 let instance = null; 69 beforeEach(async () => { 70 messageHandler = { 71 clearChildMessages: sandbox.stub().resolves(), 72 clearChildProviders: sandbox.stub().resolves(), 73 updateAdminState: sandbox.stub().resolves(), 74 }; 75 initParams.router.init.callsFake(params => { 76 routerParams = params; 77 }); 78 await ASRouterNewTabHook.createInstance(initParams); 79 instance = await ASRouterNewTabHook.getInstance(); 80 }); 81 describe("connect", () => { 82 it("before connection messageHandler methods are not called", async () => { 83 routerParams.clearChildMessages([1]); 84 routerParams.clearChildProviders(["test_provider"]); 85 routerParams.updateAdminState({ messages: {} }); 86 assert.notCalled(messageHandler.clearChildMessages); 87 assert.notCalled(messageHandler.clearChildProviders); 88 assert.notCalled(messageHandler.updateAdminState); 89 }); 90 it("after connect updateAdminState and clearChildMessages calls are forwarded to handler", async () => { 91 instance.connect(messageHandler); 92 routerParams.clearChildMessages([1]); 93 routerParams.clearChildProviders(["test_provider"]); 94 routerParams.updateAdminState({ messages: {} }); 95 assert.called(messageHandler.clearChildMessages); 96 assert.called(messageHandler.clearChildProviders); 97 assert.called(messageHandler.updateAdminState); 98 }); 99 it("calls from before connection are dropped", async () => { 100 routerParams.clearChildMessages([1]); 101 routerParams.clearChildProviders(["test_provider"]); 102 routerParams.updateAdminState({ messages: {} }); 103 instance.connect(messageHandler); 104 routerParams.clearChildMessages([1]); 105 routerParams.clearChildProviders(["test_provider"]); 106 routerParams.updateAdminState({ messages: {} }); 107 assert.calledOnce(messageHandler.clearChildMessages); 108 assert.calledOnce(messageHandler.clearChildProviders); 109 assert.calledOnce(messageHandler.updateAdminState); 110 }); 111 }); 112 describe("disconnect", () => { 113 it("calls after disconnect are dropped", async () => { 114 instance.connect(messageHandler); 115 instance.disconnect(); 116 routerParams.clearChildMessages([1]); 117 routerParams.clearChildProviders(["test_provider"]); 118 routerParams.updateAdminState({ messages: {} }); 119 assert.notCalled(messageHandler.clearChildMessages); 120 assert.notCalled(messageHandler.clearChildProviders); 121 assert.notCalled(messageHandler.updateAdminState); 122 }); 123 it("only calls from when there is a connection are forwarded", async () => { 124 routerParams.clearChildMessages([1]); 125 routerParams.clearChildProviders(["foo"]); 126 routerParams.updateAdminState({ messages: {} }); 127 instance.connect(messageHandler); 128 routerParams.clearChildMessages([200]); 129 routerParams.clearChildProviders(["bar"]); 130 routerParams.updateAdminState({ 131 messages: { 132 data: "accept", 133 }, 134 }); 135 instance.disconnect(); 136 routerParams.clearChildMessages([1]); 137 routerParams.clearChildProviders(["foo"]); 138 routerParams.updateAdminState({ messages: {} }); 139 assert.calledOnce(messageHandler.clearChildMessages); 140 assert.calledOnce(messageHandler.clearChildProviders); 141 assert.calledOnce(messageHandler.updateAdminState); 142 assert.calledWith(messageHandler.clearChildMessages, [200]); 143 assert.calledWith(messageHandler.clearChildProviders, ["bar"]); 144 assert.calledWith(messageHandler.updateAdminState, { 145 messages: { 146 data: "accept", 147 }, 148 }); 149 }); 150 }); 151 }); 152 }); 153 });