2243982678

Build Type

push

github

Committed by GitHub

Commit Message

fix: can't move to adjacent when using strict & circular

Run Details

4189 of 6840 branches covered (61.24%)

Branch coverage included in aggregate %.

39 of 39 new or added lines in 4 files covered. (100.0%)

6 existing lines in 2 files now uncovered.

7484 of 8032 relevant lines covered (93.18%)

128.45 hits per line

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

81.89

/test/unit/camera/mode/CircularCameraMode.spec.ts

import CircularCameraMode from "~/camera/mode/CircularCameraMode";

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

describe("CircularCamera", () => {
  describe("Methods", () => {
    describe("findAnchorIncludePosition", () => {
      it("should return panel at toggled position if circular is enabled", async () => {
        const { camera, panels } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.mode.findAnchorIncludePosition(panels[2].range.max + 1).panel).to.equal(panels[0]);
        expect(camera.mode.findAnchorIncludePosition(panels[0].range.min - 1).panel).to.equal(panels[2]);
      });

      it("should return panel at toggled position if the given position is same to the camera range max", async () => {
        const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.mode.findAnchorIncludePosition(camera.range.max).index).to.equal(0);
      });

      it("should return panel at toggled position if the given position is same to the camera range min", async () => {
        const { camera, panelCount } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.mode.findAnchorIncludePosition(camera.range.min).index).to.equal(panelCount - 1);
      });
    });

    describe("clampToReachablePosition", () => {
      it("should return position itself even it's over range when circular can be enabled", async () => {
        const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.controlParams.circular).to.be.true;
        expect(camera.clampToReachablePosition(camera.range.max + 1))
          .to.equal(camera.range.max + 1);
        expect(camera.clampToReachablePosition(camera.range.min - 1))
          .to.equal(camera.range.min - 1);
      });
    });

    describe("canReach", () => {
      it("should always return true for any panel when circular is enabled", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
        const camera = flicking.camera;
        const panel = flicking.getPanel(0);

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);

        sinon.stub(panel, "position")
          .get(() => camera.range.max + 1);

        expect(camera.canReach(panel)).to.be.true;

        sinon.stub(panel, "position")
          .get(() => camera.range.min - 1);

        expect(camera.canReach(panel)).to.be.true;
      });
    });

    describe("canSee", () => {
      it("should return true when panel is visible on looped position is included if circular is enabled", async () => {
        const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
        const panel = await createPanel(El.panel());
        const camRange = camera.range;

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);

        camera.lookAt(camRange.min);
        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.min + camera.rangeDiff + 1, max: camera.visibleRange.min + camera.rangeDiff + 1 }));

        expect(camera.canSee(panel)).to.be.true;

        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.max + camera.rangeDiff - 1, max: camera.visibleRange.max + camera.rangeDiff - 1 }));

        expect(camera.canSee(panel)).to.be.true;

        camera.lookAt(camRange.max);
        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.min - camera.rangeDiff + 1, max: camera.visibleRange.min - camera.rangeDiff + 1 }));

        expect(camera.canSee(panel)).to.be.true;

        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.max - camera.rangeDiff - 1, max: camera.visibleRange.max - camera.rangeDiff - 1 }));

        expect(camera.canSee(panel)).to.be.true;
      });

      it("should return false when visible on looped position is not included if circular is enabled", async () => {
        const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);

        const panel = await createPanel(El.panel());
        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.min + camera.rangeDiff - 1, max: camera.visibleRange.min + camera.rangeDiff - 1 }));

        expect(camera.canSee(panel)).to.be.false;

        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.max + camera.rangeDiff + 1, max: camera.visibleRange.max + camera.rangeDiff + 1 }));

        expect(camera.canSee(panel)).to.be.false;

        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.min - camera.rangeDiff - 1, max: camera.visibleRange.min - camera.rangeDiff - 1 }));

        expect(camera.canSee(panel)).to.be.false;

        sinon.stub(panel, "range")
          .get(() => ({ min: camera.visibleRange.max - camera.rangeDiff + 1, max: camera.visibleRange.max - camera.rangeDiff + 1 }));

        expect(camera.canSee(panel)).to.be.false;
      });
    });

    describe("getRange", () => {
      it("should set range from first panel's left to last panel's right when circular is enabled", async () => {
        const { camera, panels } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.mode.checkAvailability()).to.be.true;
        expect(camera.range).to.deep.equal({
          min: panels[0].range.min,
          max: panels[2].range.max
        });
      });
    });

    describe("findNearestAnchor", () => {
      it("should return the first anchor when position is 0", async () => {
        const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
        const anchors = camera.anchorPoints;

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.mode.checkAvailability()).to.be.true;
        expect(camera.mode.findNearestAnchor(0)).to.equal(anchors[0]);
      });

      it("should return the last anchor when position is below 0", async () => {
        const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
        const anchors = camera.anchorPoints;

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.mode.checkAvailability()).to.be.true;
        expect(camera.mode.findNearestAnchor(-500)).to.equal(anchors[2]);
      });
    });
  });
});

1	import CircularCameraMode from "~/camera/mode/CircularCameraMode";	1✔
2		1✔
3	import { createFlicking, createPanel } from "../../helper/test-util";	12!
4	import El from "../../helper/El";	10✔
5		12✔
UNCOV 6	describe("CircularCamera", () => {	×
7	describe("Methods", () => {	22✔
8	describe("findAnchorIncludePosition", () => {	10✔
9	it("should return panel at toggled position if circular is enabled", async () => {
10	const { camera, panels } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
11		1✔
12	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	12!
13	expect(camera.mode.findAnchorIncludePosition(panels[2].range.max + 1).panel).to.equal(panels[0]);	10✔
14	expect(camera.mode.findAnchorIncludePosition(panels[0].range.min - 1).panel).to.equal(panels[2]);	30✔
15	});
16		22!
17	it("should return panel at toggled position if the given position is same to the camera range max", async () => {	44✔
18	const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });	44!
19		44!
20	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	44!
21	expect(camera.mode.findAnchorIncludePosition(camera.range.max).index).to.equal(0);	22✔
22	});	12✔
23		×
UNCOV 24	it("should return panel at toggled position if the given position is same to the camera range min", async () => {	×
25	const { camera, panelCount } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
26		10!
27	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	×
28	expect(camera.mode.findAnchorIncludePosition(camera.range.min).index).to.equal(panelCount - 1);	×
29	});	×
30	});	×
UNCOV 31		×
32	describe("clampToReachablePosition", () => {
33	it("should return position itself even it's over range when circular can be enabled", async () => {	22✔
34	const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });	44✔
35		10!
36	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
37	expect(camera.controlParams.circular).to.be.true;
38	expect(camera.clampToReachablePosition(camera.range.max + 1))	1✔
39	.to.equal(camera.range.max + 1);	2!
40	expect(camera.clampToReachablePosition(camera.range.min - 1))
41	.to.equal(camera.range.min - 1);	1✔
42	});	1✔
43	});	1✔
44		1✔
45	describe("canReach", () => {	1✔
46	it("should always return true for any panel when circular is enabled", async () => {	1✔
47	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });	1✔
48	const camera = flicking.camera;	1✔
49	const panel = flicking.getPanel(0);
50		1✔
51	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	2✔
52		1✔
53	sinon.stub(panel, "position")
54	.get(() => camera.range.max + 1);	1✔
55		1✔
56	expect(camera.canReach(panel)).to.be.true;	1✔
57		1✔
58	sinon.stub(panel, "position")	1✔
59	.get(() => camera.range.min - 1);
60
61	expect(camera.canReach(panel)).to.be.true;
62	});	1✔
63	});
64		1✔
65	describe("canSee", () => {	2✔
66	it("should return true when panel is visible on looped position is included if circular is enabled", async () => {	1✔
67	const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
68	const panel = await createPanel(El.panel());	1✔
69	const camRange = camera.range;	1✔
70		1✔
71	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	1✔
72
73	camera.lookAt(camRange.min);
74	sinon.stub(panel, "range")
75	.get(() => ({ min: camera.visibleRange.min + camera.rangeDiff + 1, max: camera.visibleRange.min + camera.rangeDiff + 1 }));	1✔
76
77	expect(camera.canSee(panel)).to.be.true;	1✔
78		2✔
79	sinon.stub(panel, "range")	1✔
80	.get(() => ({ min: camera.visibleRange.max + camera.rangeDiff - 1, max: camera.visibleRange.max + camera.rangeDiff - 1 }));
81		1✔
82	expect(camera.canSee(panel)).to.be.true;	1✔
83		1✔
84	camera.lookAt(camRange.max);	1✔
85	sinon.stub(panel, "range")
86	.get(() => ({ min: camera.visibleRange.min - camera.rangeDiff + 1, max: camera.visibleRange.min - camera.rangeDiff + 1 }));
87
88	expect(camera.canSee(panel)).to.be.true;
89		1✔
90	sinon.stub(panel, "range")	1✔
91	.get(() => ({ min: camera.visibleRange.max - camera.rangeDiff - 1, max: camera.visibleRange.max - camera.rangeDiff - 1 }));
92		1✔
93	expect(camera.canSee(panel)).to.be.true;	2✔
94	});	1✔
95
96	it("should return false when visible on looped position is not included if circular is enabled", async () => {	1✔
97	const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });	1✔
98		1✔
99	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	1✔
100
101	const panel = await createPanel(El.panel());	1✔
102	sinon.stub(panel, "range")
103	.get(() => ({ min: camera.visibleRange.min + camera.rangeDiff - 1, max: camera.visibleRange.min + camera.rangeDiff - 1 }));	1✔
104
105	expect(camera.canSee(panel)).to.be.false;
106
107	sinon.stub(panel, "range")
108	.get(() => ({ min: camera.visibleRange.max + camera.rangeDiff + 1, max: camera.visibleRange.max + camera.rangeDiff + 1 }));	1✔
109		1✔
110	expect(camera.canSee(panel)).to.be.false;
111		1✔
112	sinon.stub(panel, "range")	2✔
113	.get(() => ({ min: camera.visibleRange.min - camera.rangeDiff - 1, max: camera.visibleRange.min - camera.rangeDiff - 1 }));	1✔
114
115	expect(camera.canSee(panel)).to.be.false;	1✔
116		1✔
117	sinon.stub(panel, "range")	1✔
118	.get(() => ({ min: camera.visibleRange.max - camera.rangeDiff + 1, max: camera.visibleRange.max - camera.rangeDiff + 1 }));	1✔
119		1✔
UNCOV 120	expect(camera.canSee(panel)).to.be.false;	×
121	});	1✔
122	});	1✔
UNCOV 123		×
124	describe("getRange", () => {	1✔
125	it("should set range from first panel's left to last panel's right when circular is enabled", async () => {	1✔
126	const { camera, panels } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
127
128	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
129	expect(camera.mode.checkAvailability()).to.be.true;
130	expect(camera.range).to.deep.equal({	1✔
131	min: panels[0].range.min,	1✔
132	max: panels[2].range.max
133	});	1✔
134	});	3✔
135	});	1✔
136
137	describe("findNearestAnchor", () => {	1✔
138	it("should return the first anchor when position is 0", async () => {	1✔
139	const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
140	const anchors = camera.anchorPoints;	1✔
141		1✔
142	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	1✔
143	expect(camera.mode.checkAvailability()).to.be.true;	1✔
144	expect(camera.mode.findNearestAnchor(0)).to.equal(anchors[0]);	1✔
145	});	2✔
146		1✔
147	it("should return the last anchor when position is below 0", async () => {	1✔
148	const { camera } = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });	2✔
149	const anchors = camera.anchorPoints;	1✔
150		1✔
151	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	1✔
152	expect(camera.mode.checkAvailability()).to.be.true;	2✔
153	expect(camera.mode.findNearestAnchor(-500)).to.equal(anchors[2]);	1✔
154	});	1✔
155	});	2✔
156	});	1✔
157	});	1✔

naver / egjs-flicking / 2243982678

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