4052123496

Build Type

github

Committed by GitHub

Commit Message

Merge 1fdc71012 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%)

21 existing lines in 1 file now uncovered.

8407 of 9013 relevant lines covered (93.28%)

140.04 hits per line

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

69.18

/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 { EVENTS } from "~/const/external";

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

naver / egjs-flicking / 4052123496

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