chore: add after:browser:launch node event

packages/server/test/unit/browsers/browser-cri-client_spec.ts

@@ -127,200 +127,200 @@ describe('lib/browsers/cri-client', function () {
 
       expect(criImport.Version).to.be.calledTwice
     })
+  })
 
-    context('#ensureMinimumProtocolVersion', function () {
-      function withProtocolVersion (actual, test) {
-        return getClient()
-        .then((client: any) => {
-          client.versionInfo = { 'Protocol-Version': actual }
-
-          return client.ensureMinimumProtocolVersion(test)
-        })
-      }
+  context('#ensureMinimumProtocolVersion', function () {
+    function withProtocolVersion (actual, test) {
+      return getClient()
+      .then((client: any) => {
+        client.versionInfo = { 'Protocol-Version': actual }
 
-      it('resolves if protocolVersion = current', function () {
-        return expect(withProtocolVersion('1.3', '1.3')).to.be.fulfilled
+        return client.ensureMinimumProtocolVersion(test)
       })
+    }
 
-      it('resolves if protocolVersion > current', function () {
-        return expect(withProtocolVersion('1.4', '1.3')).to.be.fulfilled
-      })
+    it('resolves if protocolVersion = current', function () {
+      return expect(withProtocolVersion('1.3', '1.3')).to.be.fulfilled
+    })
 
-      it('rejects if protocolVersion < current', function () {
-        return expect(withProtocolVersion('1.2', '1.3')).to.be
-        .rejected.then((err) => {
-          expect(stripAnsi(err.message)).to.eq(`A minimum CDP version of 1.3 is required, but the current browser has 1.2.`)
-        })
+    it('resolves if protocolVersion > current', function () {
+      return expect(withProtocolVersion('1.4', '1.3')).to.be.fulfilled
+    })
+
+    it('rejects if protocolVersion < current', function () {
+      return expect(withProtocolVersion('1.2', '1.3')).to.be
+      .rejected.then((err) => {
+        expect(stripAnsi(err.message)).to.eq(`A minimum CDP version of 1.3 is required, but the current browser has 1.2.`)
       })
     })
+  })
 
-    context('#attachToTargetUrl', function () {
-      it('creates a page client when the passed in url is found', async function () {
-        const mockPageClient = {}
+  context('#attachToTargetUrl', function () {
+    it('creates a page client when the passed in url is found', async function () {
+      const mockPageClient = {}
 
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
-        criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined, browserClient: { on, send, close } }).resolves(mockPageClient)
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
+      criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined, browserClient: { on, send, close } }).resolves(mockPageClient)
 
-        const browserClient = await getClient()
+      const browserClient = await getClient()
 
-        const client = await browserClient.attachToTargetUrl('http://foo.com')
+      const client = await browserClient.attachToTargetUrl('http://foo.com')
 
-        expect(client).to.be.equal(mockPageClient)
-      })
+      expect(client).to.be.equal(mockPageClient)
+    })
 
-      it('creates a page client when the passed in url is found and notifies the protocol manager and fully managed tabs', async function () {
-        const mockPageClient = {}
-        const protocolManager: any = {
-          connectToBrowser: sinon.stub().resolves(),
-        }
+    it('creates a page client when the passed in url is found and notifies the protocol manager and fully managed tabs', async function () {
+      const mockPageClient = {}
+      const protocolManager: any = {
+        connectToBrowser: sinon.stub().resolves(),
+      }
 
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
-        send.withArgs('Target.setDiscoverTargets', { discover: true })
-        on.withArgs('Target.targetDestroyed', sinon.match.func)
-        criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager, fullyManageTabs: true, browserClient: { on, send, close } }).resolves(mockPageClient)
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
+      send.withArgs('Target.setDiscoverTargets', { discover: true })
+      on.withArgs('Target.targetDestroyed', sinon.match.func)
+      criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager, fullyManageTabs: true, browserClient: { on, send, close } }).resolves(mockPageClient)
 
-        const browserClient = await getClient({ protocolManager, fullyManageTabs: true })
+      const browserClient = await getClient({ protocolManager, fullyManageTabs: true })
 
-        const client = await browserClient.attachToTargetUrl('http://foo.com')
+      const client = await browserClient.attachToTargetUrl('http://foo.com')
 
-        expect(client).to.be.equal(mockPageClient)
-        expect(protocolManager.connectToBrowser).to.be.calledWith(client)
-      })
+      expect(client).to.be.equal(mockPageClient)
+      expect(protocolManager.connectToBrowser).to.be.calledWith(client)
+    })
 
-      it('creates a page client when the passed in url is found and notifies the protocol manager and fully managed tabs and attaching to target throws', async function () {
-        const mockPageClient = {}
-        const protocolManager: any = {
-          connectToBrowser: sinon.stub().resolves(),
-        }
+    it('creates a page client when the passed in url is found and notifies the protocol manager and fully managed tabs and attaching to target throws', async function () {
+      const mockPageClient = {}
+      const protocolManager: any = {
+        connectToBrowser: sinon.stub().resolves(),
+      }
 
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
-        send.withArgs('Target.setDiscoverTargets', { discover: true })
-        on.withArgs('Target.targetDestroyed', sinon.match.func)
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
+      send.withArgs('Target.setDiscoverTargets', { discover: true })
+      on.withArgs('Target.targetDestroyed', sinon.match.func)
 
-        send.withArgs('Network.enable').throws(new Error('ProtocolError: Inspected target navigated or closed'))
+      send.withArgs('Network.enable').throws(new Error('ProtocolError: Inspected target navigated or closed'))
 
-        criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager, fullyManageTabs: true, browserClient: { on, send, close } }).resolves(mockPageClient)
+      criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager, fullyManageTabs: true, browserClient: { on, send, close } }).resolves(mockPageClient)
 
-        const browserClient = await getClient({ protocolManager, fullyManageTabs: true })
+      const browserClient = await getClient({ protocolManager, fullyManageTabs: true })
 
-        const client = await browserClient.attachToTargetUrl('http://foo.com')
+      const client = await browserClient.attachToTargetUrl('http://foo.com')
 
-        expect(client).to.be.equal(mockPageClient)
-        expect(protocolManager.connectToBrowser).to.be.calledWith(client)
+      expect(client).to.be.equal(mockPageClient)
+      expect(protocolManager.connectToBrowser).to.be.calledWith(client)
 
-        // This would throw if the error was not caught
-        await on.withArgs('Target.attachedToTarget').args[0][1]({ targetInfo: { type: 'worker' } })
-      })
+      // This would throw if the error was not caught
+      await on.withArgs('Target.attachedToTarget').args[0][1]({ targetInfo: { type: 'worker' } })
+    })
 
-      it('retries when the passed in url is not found', async function () {
-        sinon.stub(protocol, '_getDelayMsForRetry')
-        .onFirstCall().returns(100)
-        .onSecondCall().returns(100)
-        .onThirdCall().returns(100)
+    it('retries when the passed in url is not found', async function () {
+      sinon.stub(protocol, '_getDelayMsForRetry')
+      .onFirstCall().returns(100)
+      .onSecondCall().returns(100)
+      .onThirdCall().returns(100)
 
-        const mockPageClient = {}
+      const mockPageClient = {}
 
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }, { targetId: '3', url: 'http://baz.com' }] })
-        criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined, browserClient: { on, send, close } }).resolves(mockPageClient)
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }, { targetId: '3', url: 'http://baz.com' }] })
+      criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined, browserClient: { on, send, close } }).resolves(mockPageClient)
 
-        const browserClient = await getClient()
+      const browserClient = await getClient()
 
-        const client = await browserClient.attachToTargetUrl('http://foo.com')
+      const client = await browserClient.attachToTargetUrl('http://foo.com')
 
-        expect(client).to.be.equal(mockPageClient)
-      })
+      expect(client).to.be.equal(mockPageClient)
+    })
 
-      it('throws when the passed in url is not found after retrying', async function () {
-        sinon.stub(protocol, '_getDelayMsForRetry')
-        .onFirstCall().returns(100)
-        .onSecondCall().returns(undefined)
+    it('throws when the passed in url is not found after retrying', async function () {
+      sinon.stub(protocol, '_getDelayMsForRetry')
+      .onFirstCall().returns(100)
+      .onSecondCall().returns(undefined)
 
-        const mockPageClient = {}
+      const mockPageClient = {}
 
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
-        send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
-        criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined, browserClient: { on, send, close } }).resolves(mockPageClient)
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
+      send.withArgs('Target.getTargets').resolves({ targetInfos: [{ targetId: '1', url: 'http://foo.com' }, { targetId: '2', url: 'http://bar.com' }] })
+      criClientCreateStub.withArgs({ target: '1', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined, browserClient: { on, send, close } }).resolves(mockPageClient)
 
-        const browserClient = await getClient()
+      const browserClient = await getClient()
 
-        await expect(browserClient.attachToTargetUrl('http://baz.com')).to.be.rejected
-      })
+      await expect(browserClient.attachToTargetUrl('http://baz.com')).to.be.rejected
     })
+  })
 
-    context('#resetBrowserTargets', function () {
-      it('closes the currently attached target while keeping a tab open', async function () {
-        const mockCurrentlyAttachedTarget = {
-          targetId: '100',
-          close: sinon.stub().resolves(sinon.stub().resolves()),
-        }
+  context('#resetBrowserTargets', function () {
+    it('closes the currently attached target while keeping a tab open', async function () {
+      const mockCurrentlyAttachedTarget = {
+        targetId: '100',
+        close: sinon.stub().resolves(sinon.stub().resolves()),
+      }
 
-        const mockUpdatedCurrentlyAttachedTarget = {
-          targetId: '101',
-        }
+      const mockUpdatedCurrentlyAttachedTarget = {
+        targetId: '101',
+      }
 
-        send.withArgs('Target.createTarget', { url: 'about:blank' }).resolves(mockUpdatedCurrentlyAttachedTarget)
-        send.withArgs('Target.closeTarget', { targetId: '100' }).resolves()
-        criClientCreateStub.withArgs({ target: '101', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined }).resolves(mockUpdatedCurrentlyAttachedTarget)
+      send.withArgs('Target.createTarget', { url: 'about:blank' }).resolves(mockUpdatedCurrentlyAttachedTarget)
+      send.withArgs('Target.closeTarget', { targetId: '100' }).resolves()
+      criClientCreateStub.withArgs({ target: '101', onAsynchronousError: onError, host: HOST, port: PORT, protocolManager: undefined, fullyManageTabs: undefined }).resolves(mockUpdatedCurrentlyAttachedTarget)
 
-        const browserClient = await getClient() as any
+      const browserClient = await getClient() as any
 
-        browserClient.currentlyAttachedTarget = mockCurrentlyAttachedTarget
+      browserClient.currentlyAttachedTarget = mockCurrentlyAttachedTarget
 
-        await browserClient.resetBrowserTargets(true)
+      await browserClient.resetBrowserTargets(true)
 
-        expect(mockCurrentlyAttachedTarget.close).to.be.called
-        expect(browserClient.currentlyAttachedTarget).to.eql(mockUpdatedCurrentlyAttachedTarget)
-      })
+      expect(mockCurrentlyAttachedTarget.close).to.be.called
+      expect(browserClient.currentlyAttachedTarget).to.eql(mockUpdatedCurrentlyAttachedTarget)
+    })
 
-      it('closes the currently attached target without keeping a tab open', async function () {
-        const mockCurrentlyAttachedTarget = {
-          targetId: '100',
-          close: sinon.stub().resolves(sinon.stub().resolves()),
-        }
+    it('closes the currently attached target without keeping a tab open', async function () {
+      const mockCurrentlyAttachedTarget = {
+        targetId: '100',
+        close: sinon.stub().resolves(sinon.stub().resolves()),
+      }
 
-        send.withArgs('Target.closeTarget', { targetId: '100' }).resolves()
+      send.withArgs('Target.closeTarget', { targetId: '100' }).resolves()
 
-        const browserClient = await getClient() as any
+      const browserClient = await getClient() as any
 
-        browserClient.currentlyAttachedTarget = mockCurrentlyAttachedTarget
+      browserClient.currentlyAttachedTarget = mockCurrentlyAttachedTarget
 
-        await browserClient.resetBrowserTargets(false)
+      await browserClient.resetBrowserTargets(false)
 
-        expect(mockCurrentlyAttachedTarget.close).to.be.called
-      })
+      expect(mockCurrentlyAttachedTarget.close).to.be.called
+    })
 
-      it('throws when there is no currently attached target', async function () {
-        const browserClient = await getClient() as any
+    it('throws when there is no currently attached target', async function () {
+      const browserClient = await getClient() as any
 
-        await expect(browserClient.resetBrowserTargets()).to.be.rejected
-      })
+      await expect(browserClient.resetBrowserTargets()).to.be.rejected
     })
+  })
 
-    context('#close', function () {
-      it('closes the currently attached target if it exists and the browser client', async function () {
-        const mockCurrentlyAttachedTarget = {
-          close: sinon.stub().resolves(),
-        }
+  context('#close', function () {
+    it('closes the currently attached target if it exists and the browser client', async function () {
+      const mockCurrentlyAttachedTarget = {
+        close: sinon.stub().resolves(),
+      }
 
-        const browserClient = await getClient() as any
+      const browserClient = await getClient() as any
 
-        browserClient.currentlyAttachedTarget = mockCurrentlyAttachedTarget
+      browserClient.currentlyAttachedTarget = mockCurrentlyAttachedTarget
 
-        await browserClient.close()
+      await browserClient.close()
 
-        expect(mockCurrentlyAttachedTarget.close).to.be.called
-        expect(close).to.be.called
-      })
+      expect(mockCurrentlyAttachedTarget.close).to.be.called
+      expect(close).to.be.called
+    })
 
-      it('just the browser client with no currently attached target', async function () {
-        const browserClient = await getClient() as any
+    it('just the browser client with no currently attached target', async function () {
+      const browserClient = await getClient() as any
 
-        await browserClient.close()
+      await browserClient.close()
 
-        expect(close).to.be.called
-      })
+      expect(close).to.be.called
     })
   })
 })