4051969065

Build # 4051969065

Build Type

github

Committed by GitHub

Commit Message

Merge fd101eba1 into 4347779e6

Pull Request Pull Request #771: fix: prevent invalid coordinate value in AxesController

Run Details

4440 of 7208 branches covered (61.6%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 2 files covered. (100.0%)

22 existing lines in 2 files now uncovered.

8406 of 9012 relevant lines covered (93.28%)

140.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.08

/test/unit/control/AxesController.spec.ts

import Axes from "@egjs/axes";
import AxesController from "~/control/AxesController";
import IdleState from "~/control/states/IdleState";
import FlickingError from "~/core/FlickingError";
import * as AXES from "~/const/axes";
import * as ERROR from "~/const/error";

import El from "../helper/El";
import { createFlicking, tick } from "../helper/test-util";

describe("AxesController", () => {
  describe("Properties", () => {
    it("is not enabled by default", () => {
      expect(new AxesController().enabled).to.be.false;
    });

    it("has IdleState as a default state", () => {
      expect(new AxesController().state).to.be.an.instanceOf(IdleState);
    });

    it("has axes as null by default", () => {
      expect(new AxesController().axes).to.be.null;
    });

    it("has {start: 0, end: 0} as a default animating context", () => {
      expect(new AxesController().animatingContext).to.deep.equal({ start: 0, end: 0, offset: 0 });
    });

    it("has 0 as a default position", () => {
      expect(new AxesController().position).to.equal(0);
    });
  });

  describe("Methods", () => {
    describe("init", () => {
      it("should create axes instance on initialization", async () => {
        const controller = new AxesController();
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);

        controller.init(flicking);

        expect(controller.axes).not.to.be.null;
        expect(controller.axes).to.be.an.instanceOf(Axes);
      });
    });

    describe("destroy", () => {
      it("should also destroy axes instance", async () => {
        const controller = new AxesController();
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        controller.init(flicking);

        const destroySpy = sinon.spy(controller.axes, "destroy");
        controller.destroy();

        expect(destroySpy.calledOnce).to.be.true;
      });
    });

    describe("update", () => {
      it("should throw a FlickingError with code NOT_ATTACHED_TO_FLICKING when it's not initialized yet", async () => {
        const camera = new AxesController();

        const err = await camera.animateTo(1000, 1000).catch(e => e);

        expect(err)
          .to.be.an.instanceOf(FlickingError)
          .with.property("code", ERROR.CODE.NOT_ATTACHED_TO_FLICKING);
      });

      it("should update position to a camera's position", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const controller = flicking.control.controller;
        const prevPos = controller.position;

        flicking.camera.lookAt(1500);
        controller.update(flicking.camera.controlParams);

        expect(controller.position).to.equal(1500);
        expect(controller.position).not.to.equal(prevPos);
      });
    });

    describe("animateTo", () => {
      it("should throw a FlickingError with code NOT_ATTACHED_TO_FLICKING when it's not initialized yet", async () => {
        const camera = new AxesController();

        const err = await camera.animateTo(1000, 1000).catch(e => e);

        expect(err)
          .to.be.an.instanceOf(FlickingError)
          .with.property("code", ERROR.CODE.NOT_ATTACHED_TO_FLICKING);
      });

      it("should call `setTo` of the axes instance", async () => {
        const controller = new AxesController();
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        controller.init(flicking);
        const setToSpy = sinon.spy(controller.axes, "setTo");

        flicking.once("ready", () => {
          void controller.animateTo(1000, 1000);
          tick(2000);
          expect(setToSpy.calledOnce).to.be.true;
          expect(setToSpy.calledWithMatch({ [AXES.POSITION_KEY]: 1000 }, 1000));
        });
      });

      it("should call `setTo` of the axes onRelease event if given", async () => {
        const controller = new AxesController();
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        controller.init(flicking);
        const onReleaseMock = { setTo: sinon.spy() };

        flicking.once("ready", () => {
          void controller.animateTo(1000, 1000, onReleaseMock as any);
          tick(2000);
          expect(onReleaseMock.setTo.calledOnce).to.be.true;
          expect(onReleaseMock.setTo.calledWithMatch({ [AXES.POSITION_KEY]: 1000 }, 1000));
        });
      });

      it("should be resolved immediately if duration is 0", async () => {
        const controller = new AxesController();
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        controller.init(flicking);

        flicking.once("ready", async () => {
          await controller.animateTo(1000, 0);
          // No tick() is involved, so passing this test means that promise is resolved immediately
          expect(controller.position).to.equal(1000);
        });
      });

      it("should be resolved immediately if given position is same to current position", async () => {
        const controller = new AxesController();
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        controller.init(flicking);

        flicking.once("ready", async () => {
          const prevPos = controller.position;
          // No tick() is involved, so passing this test means that promise is resolved immediately
          await controller.animateTo(prevPos, 0);
          expect(controller.position).to.equal(prevPos);
        });
      });
    });
  });
});

1	import Axes from "@egjs/axes";	1✔
2	import AxesController from "~/control/AxesController";	1!
3	import IdleState from "~/control/states/IdleState";	×
4	import FlickingError from "~/core/FlickingError";	×
5	import * as AXES from "~/const/axes";
6	import * as ERROR from "~/const/error";	×
7		×
8	import El from "../helper/El";
9	import { createFlicking, tick } from "../helper/test-util";	1!
10		×
11	describe("AxesController", () => {
12	describe("Properties", () => {	×
13	it("is not enabled by default", () => {
14	expect(new AxesController().enabled).to.be.false;	1✔
15	});	2!
16		×
17	it("has IdleState as a default state", () => {	×
18	expect(new AxesController().state).to.be.an.instanceOf(IdleState);	×
19	});	×
20
21	it("has axes as null by default", () => {	1✔
22	expect(new AxesController().axes).to.be.null;	9!
23	});	9✔
24		9✔
25	it("has {start: 0, end: 0} as a default animating context", () => {	×
26	expect(new AxesController().animatingContext).to.deep.equal({ start: 0, end: 0, offset: 0 });	18✔
27	});	9✔
28
29	it("has 0 as a default position", () => {
30	expect(new AxesController().position).to.equal(0);	1✔
31	});	9!
32	});	9✔
33		27✔
34	describe("Methods", () => {
35	describe("init", () => {	18!
36	it("should create axes instance on initialization", async () => {	36✔
37	const controller = new AxesController();	36!
38	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	36!
39		36!
40	controller.init(flicking);	18✔
41		9✔
42	expect(controller.axes).not.to.be.null;	×
43	expect(controller.axes).to.be.an.instanceOf(Axes);	×
44	});
45	});	9!
46		×
47	describe("destroy", () => {	×
48	it("should also destroy axes instance", async () => {	×
49	const controller = new AxesController();	×
50	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	×
51	controller.init(flicking);
52		18✔
53	const destroySpy = sinon.spy(controller.axes, "destroy");	36✔
54	controller.destroy();	9!
55
56	expect(destroySpy.calledOnce).to.be.true;
57	});	1✔
58	});	5!
59
60	describe("update", () => {	1✔
61	it("should throw a FlickingError with code NOT_ATTACHED_TO_FLICKING when it's not initialized yet", async () => {	1✔
62	const camera = new AxesController();	1✔
63		1✔
64	const err = await camera.animateTo(1000, 1000).catch(e => e);	1✔
65		1✔
66	expect(err)	1✔
67	.to.be.an.instanceOf(FlickingError)	1✔
68	.with.property("code", ERROR.CODE.NOT_ATTACHED_TO_FLICKING);	1✔
69	});	1✔
70		1✔
71	it("should update position to a camera's position", async () => {	1✔
72	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
73	const controller = flicking.control.controller;
74	const prevPos = controller.position;	1✔
75		1✔
76	flicking.camera.lookAt(1500);
77	controller.update(flicking.camera.controlParams);	1✔
78		1✔
79	expect(controller.position).to.equal(1500);
80	expect(controller.position).not.to.equal(prevPos);	1✔
81	});	1✔
82	});
83		1✔
84	describe("animateTo", () => {	1✔
85	it("should throw a FlickingError with code NOT_ATTACHED_TO_FLICKING when it's not initialized yet", async () => {
86	const camera = new AxesController();
87		1✔
88	const err = await camera.animateTo(1000, 1000).catch(e => e);	1✔
89		1✔
90	expect(err)
91	.to.be.an.instanceOf(FlickingError)	1✔
92	.with.property("code", ERROR.CODE.NOT_ATTACHED_TO_FLICKING);	2✔
93	});
94		1✔
95	it("should call `setTo` of the axes instance", async () => {	1✔
96	const controller = new AxesController();
97	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
98	controller.init(flicking);	1✔
99	const setToSpy = sinon.spy(controller.axes, "setTo");	1✔
100		1✔
101	flicking.once("ready", () => {	1✔
102	void controller.animateTo(1000, 1000);
103	tick(2000);
104	expect(setToSpy.calledOnce).to.be.true;
105	expect(setToSpy.calledWithMatch({ [AXES.POSITION_KEY]: 1000 }, 1000));
106	});	1✔
107	});	1✔
108
109	it("should call `setTo` of the axes onRelease event if given", async () => {	1✔
110	const controller = new AxesController();	2✔
111	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
112	controller.init(flicking);	1✔
113	const onReleaseMock = { setTo: sinon.spy() };	1✔
114
115	flicking.once("ready", () => {	1✔
116	void controller.animateTo(1000, 1000, onReleaseMock as any);	1✔
117	tick(2000);	1✔
118	expect(onReleaseMock.setTo.calledOnce).to.be.true;	1✔
119	expect(onReleaseMock.setTo.calledWithMatch({ [AXES.POSITION_KEY]: 1000 }, 1000));	1✔
120	});	1✔
121	});
122
123	it("should be resolved immediately if duration is 0", async () => {
124	const controller = new AxesController();
125	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
126	controller.init(flicking);	1✔
127
128	flicking.once("ready", async () => {	1✔
129	await controller.animateTo(1000, 0);	2✔
130	// No tick() is involved, so passing this test means that promise is resolved immediately
131	expect(controller.position).to.equal(1000);	1✔
132	});	1✔
133	});
134		1✔
135	it("should be resolved immediately if given position is same to current position", async () => {	1✔
136	const controller = new AxesController();
137	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
138	controller.init(flicking);	1✔
139
140	flicking.once("ready", async () => {
141	const prevPos = controller.position;
142	// No tick() is involved, so passing this test means that promise is resolved immediately	1✔
143	await controller.animateTo(prevPos, 0);
144	expect(controller.position).to.equal(prevPos);	1✔
145	});	2✔
146	});	1✔
147	});
148	});	1✔
149	});	1✔

naver / egjs-flicking / 4051969065

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous