1737985161

Build Type

push

github

Committed by GitHub

Commit Message

feat: add circularFallback

Run Details

3578 of 6231 branches covered (57.42%)

Branch coverage included in aggregate %.

423 of 468 new or added lines in 13 files covered. (90.38%)

22 existing lines in 4 files now uncovered.

5290 of 5750 relevant lines covered (92.0%)

127.7 hits per line

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

87.9

/test/unit/camera/Camera.spec.ts

1	import { ALIGN, DIRECTION, EVENTS } from "~/const/external";	1✔
2	import Camera from "~/camera/Camera";	1!
NEW 3	import { BoundCameraMode, CircularCameraMode, LinearCameraMode } from "~/camera";	×
UNCOV 4	import FlickingError from "~/core/FlickingError";	×
5	import * as ERROR from "~/const/error";
6		×
NEW 7	import { createFlicking } from "../helper/test-util";	×
8	import El from "../helper/El";
9		1!
UNCOV 10	describe("Camera", () => {	×
11	describe("Properties", () => {
UNCOV 12	it("should have element undefined as default", () => {	×
13	expect(new Camera().element).to.be.undefined;
14	});	1✔
15		1!
16	it("should have position 0 as default", () => {	×
NEW 17	expect(new Camera().position).to.equal(0);	×
UNCOV 18	});	×
UNCOV 19		×
20	it("should have 0 as a default size", () => {
21	expect(new Camera().size).to.equal(0);	1✔
22	});	29✔
23		29✔
24	it("should have alignPosition 0 as default", () => {	29✔
NEW 25	expect(new Camera().alignPosition).to.equal(0);	×
26	});	58✔
27		29✔
28	it("should have range from 0 to 0 as default", () => {
29	expect(new Camera().range.min).to.equal(0);
30	expect(new Camera().range.max).to.equal(0);	1✔
31	});	29!
32		29✔
33	it("should have visiblePanels as an empty array as default", () => {	87✔
34	expect(new Camera().visiblePanels).to.be.empty;
35	});	58!
36		116✔
37	it(`should have align ${ALIGN.CENTER} as default`, () => {	116!
38	expect(new Camera().align).to.equal(ALIGN.CENTER);	116!
39	});	116!
40		58✔
41	it("should return size same to viewport width when horizontal: true", async () => {	29✔
UNCOV 42	const flicking = await await createFlicking(El.DEFAULT_HORIZONTAL, { horizontal: true });	×
NEW 43	const camera = new Camera();	×
44
45	camera.init(flicking);	29!
UNCOV 46		×
UNCOV 47	expect(camera.size).not.to.equal(0);	×
UNCOV 48	expect(camera.size).to.equal(flicking.viewport.width);	×
UNCOV 49	expect(camera.size).not.to.equal(flicking.viewport.height);	×
UNCOV 50	});	×
51
52	it("should return size same to viewport height when horizontal: false", async () => {	58✔
53	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { horizontal: false });	116✔
54	const camera = new Camera();	29!
55
56	camera.init(flicking);
57		1✔
58	expect(camera.size).not.to.equal(0);	3!
59	expect(camera.size).not.to.equal(flicking.viewport.width);
60	expect(camera.size).to.equal(flicking.viewport.height);	1✔
61	});	1✔
62		1✔
63	describe("controlParams", () => {	1✔
64	it("should return current range", () => {	1✔
65	expect(new Camera().controlParams.range).to.deep.equal(new Camera().range);	1✔
66	});	1✔
67		1✔
68	it("should return current position", async () => {	1✔
69	const camera = new Camera();	1✔
70	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
71		1✔
72	camera.init(flicking);
73	camera.lookAt(800);	1✔
74		1✔
75	expect(camera.controlParams.position).to.equal(800);
76	});	1✔
77		1✔
78	it("should always return circular as false", () => {
79	expect(new Camera().controlParams.circular).to.be.false;	1✔
80	});	1✔
81	});
82		1✔
83	describe("visibleRange", () => {	1✔
84	it("should return visible range from current position", async () => {	1✔
85	const camera = new Camera({ align: ALIGN.CENTER });
86	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
87		1✔
88	camera.init(flicking);
89	camera.updateAlignPos();	1✔
90	camera.lookAt(500);	1✔
91
92	expect(camera.visibleRange.min).to.equal(500 - flicking.viewport.width / 2);	1✔
93	expect(camera.visibleRange.max).to.equal(500 + flicking.viewport.width / 2);
94	});	1✔
95	});	3✔
96	});	1✔
97		1✔
98	describe("Methods", () => {
99	describe("init", () => {	1✔
100	it("should throw a FlickingError with code VAL_MUST_NOT_NULL when there's no camera element inside it", async () => {	1✔
101	const camera = new Camera();	1✔
102	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
103		1✔
104	// Remove viewport's children	1✔
105	while (flicking.element.firstChild) {	1✔
106	flicking.element.firstChild.remove();
107	}
108
109	expect(() => camera.init(flicking))	1✔
110	.to.throw(FlickingError)
111	.with.property("code", ERROR.CODE.VAL_MUST_NOT_NULL);	1✔
112	});	2✔
113		1✔
114	it("should set first child of the viewport element as its element", async () => {
115	const camera = new Camera();	1✔
116	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
117		1✔
118	camera.init(flicking);	1✔
119		1✔
120	expect(camera.element).to.equal(flicking.element.firstChild);	1✔
121	});	1✔
122
123	it("should use LinearCameraMode by default", async () => {
124	const camera = new Camera();
125	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
126		1✔
127	camera.init(flicking);	1✔
128
129	expect(camera.mode).to.be.an.instanceOf(LinearCameraMode);	1✔
130	});
131		1✔
132	it("should use BoundCameraMode when bound is true and the mode is available", async () => {	2✔
133	const camera = new Camera();
134	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { bound: true });	1✔
135		1✔
136	camera.init(flicking);
137		1✔
138	expect(camera.mode).to.be.an.instanceOf(BoundCameraMode);	1✔
139	expect(camera.mode.checkAvailability()).to.be.true;	1✔
140	});	1✔
141		1✔
142	it("should use CircularCameraMode when circular is true and the mode is available", async () => {
143	const camera = new Camera();
144	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
145		1✔
146	camera.init(flicking);	1✔
147
148	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
149	expect(camera.mode.checkAvailability()).to.be.true;	1✔
150	});	1✔
151
152	it("should use LinearCameraMode when circular is true but it's not available & circularFallback is 'default'", async () => {	1✔
153	const camera = new Camera();	2✔
154	const flicking = await createFlicking(El.viewport().add(El.camera()), { circular: true, circularFallback: "default" });
155		1✔
156	camera.init(flicking);	1✔
157
158	expect(camera.mode).to.be.an.instanceOf(LinearCameraMode);	1✔
159	});	1✔
160		1✔
161	it("should use BoundCameraMode when circular is true but it's not available & circularFallback is 'default'", async () => {	1✔
162	const camera = new Camera();	1✔
163	const flicking = await createFlicking(El.viewport().add(El.camera()), { circular: true, circularFallback: "bound" });	1✔
164		1✔
165	camera.init(flicking);
166
167	expect(camera.mode).to.be.an.instanceOf(BoundCameraMode);
168	});
169	});
170		1✔
171	describe("lookAt", () => {	1✔
172	it("should throw a FlickingError with code NOT_ATTACHED_TO_FLICKING when it's not initialized yet", async () => {	1✔
173	const camera = new Camera();
174		1✔
175	expect(() => camera.lookAt(500))	2✔
176	.to.throw(FlickingError)
177	.with.property("code", ERROR.CODE.NOT_ATTACHED_TO_FLICKING);	1✔
178	});	1✔
179
180	it("should set position to given value", async () => {	1✔
181	const camera = new Camera();
182	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
183	const prevPosition = camera.position;	1✔
184
185	camera.init(flicking);	1✔
186	camera.lookAt(500);
187
188	expect(camera.position).not.to.equal(prevPosition);	1✔
189	expect(camera.position).to.equal(500);
190	});
191
192	it("should apply transform to camera element", async () => {	1✔
193	const camera = new Camera();
194	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
195		2✔
196	camera.init(flicking);
197	camera.lookAt(500);	1✔
198		1✔
199	expect(camera.element.style.transform).to.equal(`translate(${-(500 - camera.alignPosition)}px)`);
200	});	1✔
201		1✔
202	it("should update visible panels", async () => {	1✔
203	const camera = new Camera();	1✔
204	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
205
206	camera.init(flicking);
207	camera.lookAt(500);	1✔
208
209	expect(camera.visiblePanels).not.to.be.empty;	1✔
210	});	2✔
211
212	it(`should trigger flicking's ${EVENTS.VISIBLE_CHANGE} on visible panels update`, async () => {	1✔
213	const camera = new Camera();	1✔
214	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
215	const visibleChangeSpy = sinon.spy();	1✔
216		1✔
217	flicking.on(EVENTS.VISIBLE_CHANGE, visibleChangeSpy);	1✔
218	camera.init(flicking);	1✔
219	camera.lookAt(500);
220
221	await (async () => void 0)();
222		1✔
223	expect(visibleChangeSpy.calledOnce).to.be.true;
224	});	1✔
225		2✔
226	it(`should trigger flicking's ${EVENTS.NEED_PANEL} for both sides when there're no panels`, async () => {
227	const camera = new Camera();	1✔
228	const flicking = await createFlicking(El.viewport().add(El.camera()));	1✔
229	const needPanelSpy = sinon.spy();
230		1✔
231	flicking.on(EVENTS.NEED_PANEL, needPanelSpy);	1✔
232	camera.init(flicking);	1✔
233	camera.lookAt(500);	1✔
234		1✔
235	expect(needPanelSpy.calledTwice).to.be.true;
236	expect(needPanelSpy.calledWithMatch({ direction: DIRECTION.NEXT })).to.be.true;
237	expect(needPanelSpy.calledWithMatch({ direction: DIRECTION.PREV })).to.be.true;
238	});	1✔
239
240	it(`should trigger flicking's ${EVENTS.REACH_EDGE} when moving to range.min`, async () => {	1✔
241	const camera = new Camera();	2✔
242	const flicking = await createFlicking(El.viewport().add(El.camera()));
243	const reachEdgeSpy = sinon.spy();	1✔
244		1✔
245	(camera as any)._range = { min: -1000, max: 1000 };
246	camera.init(flicking);	1✔
247	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);	1✔
248	camera.lookAt(-1000);	1✔
249		1✔
250	expect(reachEdgeSpy.calledOnce).to.be.true;	1✔
251	expect(reachEdgeSpy.calledWithMatch({ direction: DIRECTION.PREV })).to.be.true;
252	});
253
254	it(`should trigger flicking's ${EVENTS.REACH_EDGE} when moving to range.max`, async () => {	1✔
255	const camera = new Camera();
256	const flicking = await createFlicking(El.viewport().add(El.camera()));	1✔
257	const reachEdgeSpy = sinon.spy();	2✔
258
259	(camera as any)._range = { min: -1000, max: 1000 };	1✔
260	camera.init(flicking);	1✔
261	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
262	camera.lookAt(1000);	1✔
263		1✔
264	expect(reachEdgeSpy.calledOnce).to.be.true;	1✔
265	expect(reachEdgeSpy.calledWithMatch({ direction: DIRECTION.NEXT })).to.be.true;	1✔
266	});
267
268	it(`should noot trigger flicking's ${EVENTS.REACH_EDGE} when moving from outside of range to range.min`, async () => {
269	const camera = new Camera();	1✔
270	const flicking = await createFlicking(El.viewport().add(El.camera()));
271	const reachEdgeSpy = sinon.spy();	1✔
272		2✔
273	(camera as any)._range = { min: -1000, max: 1000 };
274	camera.init(flicking);	1✔
275	camera.lookAt(-1001); // Move to outside	1✔
276	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
277	camera.lookAt(-1000); // Move to outside	1✔
278		1✔
279	expect(reachEdgeSpy.called).to.be.false;	1✔
280	});	1✔
281
282	it(`should noot trigger flicking's ${EVENTS.REACH_EDGE} when moving from outside of range to range.max`, async () => {
283	const camera = new Camera();
284	const flicking = await createFlicking(El.viewport().add(El.camera()));
285	const reachEdgeSpy = sinon.spy();	1✔
286		1✔
287	(camera as any)._range = { min: -1000, max: 1000 };
288	camera.init(flicking);	1✔
289	camera.lookAt(1001); // Move to outside	1✔
290	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);	1✔
291	camera.lookAt(1000); // Move to outside
292
293	expect(reachEdgeSpy.called).to.be.false;	1✔
294	});
295	});
296		1✔
297	describe("findAnchorIncludePosition", () => {
298	it("should return panel at given position", async () => {	1✔
299	const camera = new Camera();	2✔
300	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
301	const panels = flicking.panels;	1✔
302		1✔
303	camera.init(flicking);
304	camera.updateAnchors();	1✔
305		1✔
306	expect(camera.findAnchorIncludePosition(panels[0].position).panel).to.equal(panels[0]);	1✔
307	expect(camera.findAnchorIncludePosition(panels[1].position).panel).to.equal(panels[1]);	1✔
308	expect(camera.findAnchorIncludePosition(panels[2].position).panel).to.equal(panels[2]);	1✔
309	});	1✔
310		1✔
311	it("should return null when no panel includes given position", async () => {
312	const camera = new Camera();
313	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
314	const panels = flicking.panels;	1✔
315
316	camera.init(flicking);	1✔
317	camera.updateAnchors();	2✔
318
319	expect(camera.findAnchorIncludePosition(-999999999)).to.be.null;	1✔
320	expect(camera.findAnchorIncludePosition(999999999)).to.be.null;	1✔
321	expect(camera.findAnchorIncludePosition(panels[2].range.max + 1)).to.be.null;
322	expect(camera.findAnchorIncludePosition(panels[0].range.min - 1)).to.be.null;	1✔
323	});	1✔
324	});	1✔
325		1✔
326	describe("findNearestAnchor", () => {	1✔
327	it("should return null when there're no panels", async () => {
328	const camera = new Camera();
329	const flicking = await createFlicking(El.viewport().add(El.camera()));
330		1✔
331	camera.init(flicking);
332	camera.updateAnchors();	1✔
333		2✔
334	expect(camera.findNearestAnchor(0)).to.be.null;
335	});	1✔
336		1✔
337	it("should return correct panel underneath it", async () => {
338	const camera = new Camera();	1✔
339	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
340		1✔
341	camera.init(flicking);	1✔
342	camera.updateAnchors();	1✔
343	camera.lookAt(flicking.getPanel(1).position);
344
345	const nearestAnchor = camera.findNearestAnchor(camera.position);
346	expect(nearestAnchor.panel).to.equal(flicking.getPanel(1));	1✔
347	expect(nearestAnchor.position).to.equal(flicking.getPanel(1).position);
348	});	1✔
349	});	3✔
350
351	describe("updateRange", () => {	1✔
352	it("should update mode before setting new range", async () => {	1✔
353	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
354	const camera = flicking.camera;	1✔
355	const prevMode = camera.mode;	1✔
356		1✔
357	flicking.circular = true; // This should change mode to Circular	1✔
358	camera.updateRange();	1✔
359		1✔
360	const newMode = camera.mode;	1✔
361	expect(newMode).not.to.equal(prevMode);
362	expect(newMode).to.be.instanceOf(CircularCameraMode);
363	});	1✔
364	});	1✔
365		1✔
366	describe("updateAlignPos", () => {
367	it("should update alignPosition using current align value", async () => {
368	const camera = new Camera({ align: "80%" });
369	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
370	const prevAlignPosition = camera.alignPosition;
371		1✔
372	camera.init(flicking);	2✔
373	camera.updateAlignPos();
374		1✔
375	expect(camera.alignPosition).not.to.equal(prevAlignPosition);	1✔
376	expect(camera.alignPosition).to.equal(flicking.viewport.width * 0.8);
377	});	1✔
378		1✔
379	it("should use property 'camera' if align is given as an object", async () => {	1✔
380	const camera = new Camera({ align: { panel: "30%", camera: "70%" } });	1✔
381	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
382	const prevAlignPosition = camera.alignPosition;	1✔
383		1✔
384	camera.init(flicking);	1✔
385	camera.updateAlignPos();	1✔
386
387	expect(camera.alignPosition).not.to.equal(prevAlignPosition);
388	expect(camera.alignPosition).to.equal(flicking.viewport.width * 0.7);
389	});	1✔
390	});
391	});	1✔
392	});	2✔

naver / egjs-flicking / 1737985161

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