@ionic/core 7.5.6-dev.11700168085.18cb70d3 → 7.5.6-dev.11700492285.1581ed02

package/dist/collection/components/nav/test/nav-controller.spec.js

@@ -0,0 +1,749 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { newSpecPage } from "@stencil/core/testing";
+import { Nav } from "../nav";
+import { ViewController } from "../view-controller";
+describe('NavController', () => {
+  describe('push and pop', () => {
+    it('should push multiple times and pop multiple times', async () => {
+      const push1Done = jest.fn();
+      const push2Done = jest.fn();
+      const push3Done = jest.fn();
+      const push4Done = jest.fn();
+      const pop1Done = jest.fn();
+      const pop2Done = jest.fn();
+      const pop3Done = jest.fn();
+      // Push 1
+      const view1 = mockView(MockView1);
+      await nav.push(view1, null, { animated: false }, push1Done);
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(push1Done).toHaveBeenCalledWith(hasCompleted, requiresTransition, view1, undefined, 'forward');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      // Push 2
+      const view2 = mockView(MockView2);
+      await nav.push(view2, null, { animated: false }, push2Done);
+      expect(push2Done).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view1, 'forward');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+      // Push 3
+      const view3 = mockView(MockView3);
+      await nav.push(view3, null, { animated: false }, push3Done);
+      expect(push3Done).toHaveBeenCalledWith(hasCompleted, requiresTransition, view3, view2, 'forward');
+      expect(nav.getLength()).toEqual(3);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+      expect(nav['views'][2].component).toEqual(MockView3);
+      // Push 4
+      const view4 = mockView(MockView4);
+      await nav.push(view4, null, { animated: false }, push4Done);
+      expect(push4Done).toHaveBeenCalledWith(hasCompleted, requiresTransition, view4, view3, 'forward');
+      expect(nav.getLength()).toEqual(4);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+      expect(nav['views'][2].component).toEqual(MockView3);
+      expect(nav['views'][3].component).toEqual(MockView4);
+      // Pop 1
+      await nav.pop({ animated: false }, pop1Done);
+      expect(pop1Done).toHaveBeenCalledWith(hasCompleted, requiresTransition, view3, view4, 'back');
+      expect(nav.getLength()).toEqual(3);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+      expect(nav['views'][2].component).toEqual(MockView3);
+      // Pop 2
+      await nav.pop({ animated: false }, pop2Done);
+      expect(pop2Done).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view3, 'back');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+      // Pop 3
+      await nav.pop({ animated: false }, pop3Done);
+      expect(pop3Done).toHaveBeenCalledWith(hasCompleted, requiresTransition, view1, view2, 'back');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+    }, 10000);
+  });
+  describe('push', () => {
+    it('should push a component as the first view', async () => {
+      const view1 = mockView(MockView1);
+      await nav.push(view1, null, null, trnsDone);
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view1, undefined, 'forward');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['isTransitioning']).toEqual(false);
+    }, 10000);
+    it('should push a component as the second view at the end', async () => {
+      const view1 = mockView(MockView1);
+      mockViews(nav, [view1]);
+      const view2 = mockView(MockView2);
+      await nav.push(view2, null, null, trnsDone);
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view1, 'forward');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+      expect(nav['isTransitioning']).toEqual(false);
+    }, 10000);
+    it('should push a ViewController as the second view and fire lifecycles', async () => {
+      const view1 = mockView();
+      const view2 = mockView();
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      mockViews(nav, [view1]);
+      await nav.push(view2, null, null, trnsDone);
+      expect(instance1.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).not.toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view1, 'forward');
+      expect(nav.getLength()).toEqual(2);
+    }, 10000);
+  });
+  describe('insert', () => {
+    it('should insert at the beginning with no async transition', async () => {
+      const view4 = mockView(MockView4);
+      const instance4 = spyOnLifecycles(view4);
+      const opts = {};
+      mockViews(nav, [mockView(MockView1), mockView(MockView2), mockView(MockView3)]);
+      await nav.insert(0, view4, null, opts, trnsDone);
+      expect(instance4.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillUnload).not.toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = false;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, undefined, undefined, undefined);
+      expect(nav.getLength()).toEqual(4);
+      expect(nav['views'][0].component).toEqual(MockView4);
+      expect(nav['views'][nav.getLength() - 1].component).toEqual(MockView3);
+    }, 10000);
+    it('should insert at the end when given -1', async () => {
+      const opts = {};
+      const view1 = mockView(MockView1);
+      mockViews(nav, [view1]);
+      const view2 = mockView(MockView2);
+      await nav.insert(-1, view2, null, opts, trnsDone);
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view1, 'forward');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][nav.getLength() - 1].component).toEqual(MockView2);
+    }, 10000);
+    it('should insert at the end when given a number greater than actual length', async () => {
+      const view1 = mockView(MockView1);
+      mockViews(nav, [view1]);
+      const view2 = mockView(MockView2);
+      await nav.insert(9999, view2, null, null, trnsDone);
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view1, 'forward');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][nav.getLength() - 1].component).toEqual(MockView2);
+    }, 10000);
+    it('should not insert if null view', (done) => {
+      mockViews(nav, [mockView(MockView1)]);
+      nav
+        .insert(-1, null, null, null, trnsDone)
+        .then(() => {
+        fail('it should not succeed');
+      })
+        .catch((err) => {
+        const hasCompleted = false;
+        const requiresTransition = false;
+        const rejectReason = new Error('invalid views to insert');
+        expect(err).toEqual(rejectReason);
+        expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, rejectReason);
+        expect(nav.getLength()).toEqual(1);
+        expect(nav['views'][nav.getLength() - 1].component).toEqual(MockView1);
+        done();
+      });
+    }, 10000);
+  });
+  describe('insertPages', () => {
+    it('should insert all pages in the middle', async () => {
+      const view4 = mockView(MockView4);
+      const instance4 = spyOnLifecycles(view4);
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      mockViews(nav, [view1, view2, view3]);
+      const view5 = mockView(MockView5);
+      await nav.insertPages(1, [view4, view5], null, trnsDone);
+      expect(instance4.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillUnload).not.toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = false;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, undefined, undefined, undefined);
+      expect(nav.getLength()).toEqual(5);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView4);
+      expect(nav['views'][2].component).toEqual(MockView5);
+      expect(nav['views'][3].component).toEqual(MockView2);
+      expect(nav['views'][4].component).toEqual(MockView3);
+      expect(nav['views'][1].nav).toEqual(nav);
+      expect(nav['views'][2].nav).toEqual(nav);
+    }, 10000);
+  });
+  describe('pop', () => {
+    it('should not pop when no views in the stack', (done) => {
+      nav
+        .pop(null, trnsDone)
+        .then(() => {
+        fail('it should not succeed');
+      })
+        .catch((err) => {
+        const hasCompleted = false;
+        const requiresTransition = false;
+        const rejectReason = new Error('no views in the stack to be removed');
+        expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, rejectReason);
+        expect(err).toEqual(rejectReason);
+        expect(nav.getLength()).toEqual(0);
+        expect(nav['isTransitioning']).toEqual(false);
+        done();
+      });
+    }, 10000);
+    it('should remove the last view and fire lifecycles', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      mockViews(nav, [view1, view2]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      await nav.pop(null, trnsDone);
+      expect(instance1.ionViewWillEnter).toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view1, view2, 'back');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['isTransitioning']).toEqual(false);
+    }, 10000);
+  });
+  describe('popTo', () => {
+    it('should pop to a view', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      mockViews(nav, [view1, view2, view3]);
+      await nav.popTo(view2, null, trnsDone);
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view3, 'back');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+    }, 10000);
+    it('should pop to using an index number', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      const view4 = mockView(MockView4);
+      mockViews(nav, [view1, view2, view3, view4]);
+      await nav.popTo(1, null, trnsDone);
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view4, 'back');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+    }, 10000);
+    it('should pop to first using an index number', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      const view4 = mockView(MockView4);
+      mockViews(nav, [view1, view2, view3, view4]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      const instance4 = spyOnLifecycles(view4);
+      await nav.popTo(0, null, trnsDone);
+      expect(instance1.ionViewWillEnter).toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance4.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance4.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance4.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view1, view4, 'back');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+    }, 10000);
+  });
+  describe('popToRoot', () => {
+    it('should pop to the first view', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      const view4 = mockView(MockView4);
+      mockViews(nav, [view1, view2, view3, view4]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      const instance4 = spyOnLifecycles(view4);
+      await nav.popToRoot(null, trnsDone);
+      expect(instance1.ionViewWillEnter).toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance4.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance4.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance4.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view1, view4, 'back');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+    }, 10000);
+    it("should not pop first view if it's the only view", async () => {
+      const view1 = mockView(MockView1);
+      mockViews(nav, [view1]);
+      await nav.popToRoot(null, trnsDone);
+      const hasCompleted = true;
+      const requiresTransition = false;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, undefined, undefined, undefined);
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+    }, 10000);
+  });
+  describe('remove', () => {
+    it('should remove the first three views in the beginning, no last view transition', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      const view4 = mockView(MockView4);
+      mockViews(nav, [view1, view2, view3, view4]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      const instance4 = spyOnLifecycles(view4);
+      await nav.removeIndex(0, 3, null, trnsDone);
+      expect(instance1.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance4.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillUnload).not.toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = false;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, undefined, undefined, undefined);
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView4);
+    }, 10000);
+    it('should remove two views in the middle', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      const view4 = mockView(MockView4);
+      const view5 = mockView(MockView5);
+      mockViews(nav, [view1, view2, view3, view4, view5]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      const instance4 = spyOnLifecycles(view4);
+      const instance5 = spyOnLifecycles(view5);
+      await nav.removeIndex(2, 2, null, trnsDone);
+      expect(instance1.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance4.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance4.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance4.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance5.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance5.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance5.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance5.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance5.ionViewWillUnload).not.toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = false;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, undefined, undefined, undefined);
+      expect(nav.getLength()).toEqual(3);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+      expect(nav['views'][2].component).toEqual(MockView5);
+    }, 10000);
+    it('should remove the last two views at the end', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      const view4 = mockView(MockView4);
+      mockViews(nav, [view1, view2, view3, view4]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      const instance4 = spyOnLifecycles(view4);
+      await nav.removeIndex(2, 2, null, trnsDone);
+      expect(instance1.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance4.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance4.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance4.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance4.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view4, 'back');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][0].component).toEqual(MockView1);
+      expect(nav['views'][1].component).toEqual(MockView2);
+    }, 10000);
+  });
+  describe('setRoot', () => {
+    it('should set a ViewController as the root when its the last view, no transition', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      mockViews(nav, [view1, view2, view3]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      await nav.setRoot(view3, null, null, trnsDone);
+      expect(instance1.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).not.toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = false;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, undefined, undefined, undefined);
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView3);
+    }, 10000);
+    it('should set a ViewController as the root when its the middle view, with transition', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      mockViews(nav, [view1, view2, view3]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      await nav.setRoot(view2, null, null, trnsDone);
+      expect(instance1.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view2, view3, 'back');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView2);
+    }, 10000);
+    it('should set a ViewController as the root when its the first view, with transition', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      mockViews(nav, [view1, view2, view3]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      await nav.setRoot(view1, null, null, trnsDone);
+      expect(instance1.ionViewWillEnter).toHaveBeenCalled();
+      expect(instance1.ionViewDidEnter).toHaveBeenCalled();
+      expect(instance1.ionViewWillLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewDidLeave).not.toHaveBeenCalled();
+      expect(instance1.ionViewWillUnload).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance2.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance2.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance3.ionViewWillEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewDidEnter).not.toHaveBeenCalled();
+      expect(instance3.ionViewWillLeave).toHaveBeenCalled();
+      expect(instance3.ionViewDidLeave).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view1, view3, 'back');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView1);
+    }, 10000);
+    it('should set a page component as the root, with transition', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      const view3 = mockView(MockView3);
+      mockViews(nav, [view1, view2, view3]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const instance3 = spyOnLifecycles(view3);
+      const view4 = mockView(MockView4);
+      await nav.setRoot(view4, null, null, trnsDone);
+      expect(instance1.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance3.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view4, view3, 'back');
+      expect(nav.getLength()).toEqual(1);
+      expect(nav['views'][0].component).toEqual(MockView4);
+    }, 10000);
+  });
+  describe('setPages', () => {
+    it('should set the pages from an array, starting at the root, with transition', async () => {
+      const view1 = mockView(MockView1);
+      const view2 = mockView(MockView2);
+      mockViews(nav, [view1, view2]);
+      const instance1 = spyOnLifecycles(view1);
+      const instance2 = spyOnLifecycles(view2);
+      const view4 = mockView(MockView4);
+      const view5 = mockView(MockView5);
+      await nav.setPages([{ component: view4 }, { component: view5 }], null, trnsDone);
+      expect(instance1.ionViewWillUnload).toHaveBeenCalled();
+      expect(instance2.ionViewWillUnload).toHaveBeenCalled();
+      const hasCompleted = true;
+      const requiresTransition = true;
+      expect(trnsDone).toHaveBeenCalledWith(hasCompleted, requiresTransition, view5, view2, 'back');
+      expect(nav.getLength()).toEqual(2);
+      expect(nav['views'][0].component).toEqual(MockView4);
+      expect(nav['views'][1].component).toEqual(MockView5);
+    }, 10000);
+  });
+  describe('canStart', () => {
+    it('should not swipe back when its not enabled', () => {
+      nav.swipeGesture = false;
+      const view1 = mockView();
+      const view2 = mockView();
+      mockViews(nav, [view1, view2]);
+      const result = nav['canStart']();
+      expect(result).toEqual(false);
+    });
+    it('should swipe back when has a view to go back to', () => {
+      nav.swipeGesture = true;
+      const view1 = mockView();
+      const view2 = mockView();
+      mockViews(nav, [view1, view2]);
+      const result = nav['canStart']();
+      expect(result).toEqual(true);
+    });
+  });
+  function spyOnLifecycles(view) {
+    const element = view.element;
+    Object.assign(element, {
+      ionViewWillEnter: () => {
+        return;
+      },
+      ionViewDidEnter: () => {
+        return;
+      },
+      ionViewWillLeave: () => {
+        return;
+      },
+      ionViewDidLeave: () => {
+        return;
+      },
+      ionViewWillUnload: () => {
+        return;
+      },
+    });
+    const instance = {
+      ionViewWillEnter: jest.spyOn(element, 'ionViewWillEnter'),
+      ionViewDidEnter: jest.spyOn(element, 'ionViewDidEnter'),
+      ionViewWillLeave: jest.spyOn(element, 'ionViewWillLeave'),
+      ionViewDidLeave: jest.spyOn(element, 'ionViewDidLeave'),
+      ionViewWillUnload: jest.spyOn(element, 'ionViewWillUnload'),
+    };
+    element.dispatchEvent = (ev) => {
+      switch (ev.type) {
+        case 'ionViewWillEnter':
+          element.ionViewWillEnter();
+          break;
+        case 'ionViewDidEnter':
+          element.ionViewDidEnter();
+          break;
+        case 'ionViewWillLeave':
+          element.ionViewWillLeave();
+          break;
+        case 'ionViewDidLeave':
+          element.ionViewDidLeave();
+          break;
+        case 'ionViewWillUnload':
+          element.ionViewWillUnload();
+          break;
+      }
+    };
+    return instance;
+  }
+  let trnsDone;
+  let nav;
+  beforeEach(async () => {
+    trnsDone = jest.fn();
+    const page = await newSpecPage({
+      components: [Nav],
+      html: `<ion-nav></ion-nav>`,
+      autoApplyChanges: true,
+    });
+    nav = page.rootInstance;
+  });
+  const MockView = 'mock-view';
+  const MockView1 = 'mock-view1';
+  const MockView2 = 'mock-view2';
+  const MockView3 = 'mock-view3';
+  const MockView4 = 'mock-view4';
+  const MockView5 = 'mock-view5';
+  const mockWebAnimation = (el) => {
+    Element.prototype.animate = jest.fn();
+    el.animate = () => {
+      const animation = {
+        stop: jest.fn(),
+        pause: jest.fn(),
+        cancel: jest.fn(),
+        onfinish: undefined,
+      };
+      animation.play = () => {
+        if (animation.onfinish) {
+          animation.onfinish();
+        }
+      };
+      return animation;
+    };
+  };
+  function mockView(component, params) {
+    if (!component) {
+      component = MockView;
+    }
+    const view = new ViewController(component, params);
+    view.element = document.createElement(component);
+    mockWebAnimation(view.element);
+    return view;
+  }
+  function mockViews(navI, views) {
+    navI['views'] = views;
+    views.forEach((v) => {
+      v.nav = navI;
+    });
+  }
+  // function mockNavController(): Promise<Nav> {
+  //   const navI = new Nav() as any;
+  //   navI.animated = false;
+  //   navI.el = win.document.createElement('ion-nav');
+  //   navI.win = win;
+  //   navI.queue = { write: (fn: any) => fn(), read: (fn: any) => fn() };
+  //   navI.config = new Config();
+  //   navI.config.reset({ animated: false });
+  //   navI._viewInit = (enteringView: ViewController) => {
+  //     if (!enteringView.element) {
+  //       enteringView.element = (typeof enteringView.component === 'string')
+  //         ? win.document.createElement(enteringView.component)
+  //         : enteringView.element = enteringView.component as HTMLElement;
+  //     }
+  //     enteringView.state = VIEW_STATE_ATTACHED;
+  //   };
+  //   return navI;
+  // }
+});