Debian Codegraph @

packages/popper/tests/functional/lifecycle.js

raw
1 import Popper from '../../src/index.js';
2 import makePopperFactory from '../utils/makePopperFactory';
3 import makeConnectedElement from '@popperjs/test-utils/utils/makeConnectedElement';
4 import makeConnectedScrollElement from '@popperjs/test-utils/utils/makeConnectedScrollElement';
5 import makeElement from '@popperjs/test-utils/utils/makeElement';
6 import '@popperjs/test-utils/setup';
7
8 [true, false].forEach((positionFixed) => {
9
10 describe('[lifecycle]' + (positionFixed ? ' Fixed' : ''), () => {
11
12 beforeEach(function(){
13 Popper.Defaults.positionFixed = positionFixed;
14 });
15
16 const makePopper = makePopperFactory();
17
18 describe('on creation', () => {
19 it('adds a resize event listener', () => {
20 spyOn(window, 'addEventListener');
21
22 const { state } = makePopper(
23 makeConnectedElement(),
24 makeConnectedElement()
25 );
26
27 expect(window.addEventListener.calls.argsFor(0)).toEqual([
28 'resize',
29 state.updateBound,
30 { passive: true },
31 ]);
32 });
33
34 it('adds a scroll event listener to window when boundariesElement is viewport', () => {
35 spyOn(window, 'addEventListener');
36
37 const {
38 state,
39 } = makePopper(makeConnectedElement(), makeConnectedElement(), {
40 boundariesElement: 'viewport',
41 });
42
43 expect(window.addEventListener.calls.argsFor(1)).toEqual([
44 'scroll',
45 state.updateBound,
46 { passive: true },
47 ]);
48 });
49
50 it('adds a scroll event listener to the closest scroll ancestor of reference when boundariesElement is an element', () => {
51 const boundariesElement = makeConnectedElement();
52 const scrollAncestor = document.createElement('div');
53 const reference = document.createElement('div');
54 const popper = document.createElement('div');
55
56 boundariesElement.appendChild(scrollAncestor);
57 scrollAncestor.appendChild(reference);
58 scrollAncestor.appendChild(popper);
59
60 scrollAncestor.style.overflow = 'scroll';
61
62 spyOn(scrollAncestor, 'addEventListener');
63 const { state } = makePopper(reference, popper, {
64 boundariesElement: boundariesElement,
65 });
66
67 expect(scrollAncestor.addEventListener.calls.allArgs()).toEqual([
68 ['scroll', state.updateBound, { passive: true }],
69 ]);
70 });
71
72 it('should not add resize/scroll event if eventsEnabled option is set to false', () => {
73 const {
74 state,
75 } = makePopper(makeConnectedElement(), makeConnectedElement(), {
76 eventsEnabled: false,
77 });
78
79 expect(state.eventsEnabled).toBe(false);
80 expect(state.updateBound).toBeUndefined();
81 expect(state.scrollElement).toBeUndefined();
82 });
83 });
84
85 describe('on update', () => {
86 it('should call update callback', done => {
87 const popperElement = makeConnectedElement();
88
89 let isOnCreateCalled = false;
90
91 new Popper(makeConnectedElement(), popperElement, {
92 onCreate: data => {
93 isOnCreateCalled = true;
94 data.instance.scheduleUpdate();
95 },
96 onUpdate: () => {
97 // makes sure it's executed after `onCreate`
98 expect(isOnCreateCalled).toBe(true);
99 // makes sure it's executed
100 done();
101 },
102 });
103 });
104 });
105
106 describe('on destroy', () => {
107
108 const mockStyles = {
109 top: '100px',
110 left: '100px',
111 right: '100px',
112 bottom: '100px',
113 position: 'absolute',
114 transform: 'translate3d(100px, 100px, 0)',
115 willChange: 'transform',
116 }
117
118 it('removes the resize event listener from window', () => {
119 spyOn(window, 'removeEventListener');
120
121 const instance = new Popper(
122 makeConnectedElement(),
123 makeConnectedElement()
124 );
125 const { updateBound } = instance.state;
126 instance.destroy();
127
128 expect(window.removeEventListener.calls.argsFor(0)).toEqual([
129 'resize',
130 updateBound,
131 ]);
132 });
133
134 it('removes the scroll event listener from window', () => {
135 spyOn(window, 'removeEventListener');
136
137 const instance = new Popper(
138 makeConnectedElement(),
139 makeConnectedElement()
140 );
141 const { updateBound } = instance.state;
142 instance.destroy();
143
144 expect(window.removeEventListener.calls.argsFor(1)).toEqual([
145 'scroll',
146 updateBound,
147 ]);
148 });
149
150 it('should clean up the popper element\'s styles if modifiers.applyStyle is enabled', () => {
151 const popperElement = makeConnectedElement();
152
153 for (const key in mockStyles) {
154 if (mockStyles.hasOwnProperty(key)) {
155 popperElement.style[key] = mockStyles[key];
156 }
157 }
158
159 const instance = new Popper(makeConnectedElement(), popperElement, {
160 modifiers: { applyStyle: { enabled: true } },
161 });
162
163 instance.destroy();
164
165 for (const key in mockStyles) {
166 if (mockStyles.hasOwnProperty(key)) {
167 expect(popperElement.style[key]).toBe('');
168 }
169 }
170 });
171
172 it('should not modify the popper element\'s styles if modifiers.applyStyle is disabled', () => {
173 const popperElement = makeConnectedElement();
174
175 for (const key in mockStyles) {
176 if (mockStyles.hasOwnProperty(key)) {
177 popperElement.style[key] = mockStyles[key];
178 }
179 }
180
181 const instance = new Popper(makeConnectedElement(), popperElement, {
182 modifiers: { applyStyle: { enabled: false } },
183 });
184
185 instance.destroy();
186
187 for (const key in mockStyles) {
188 if (mockStyles.hasOwnProperty(key)) {
189 expect(popperElement.style[key]).not.toBe('');
190 }
191 }
192 });
193
194 it('should not call update after destroy', () => {
195 let isUpdateCalled = false;
196
197 const popperElement = makeConnectedElement();
198
199 const instance = new Popper(makeConnectedElement(), popperElement, {
200 onUpdate: () => {
201 isUpdateCalled = true;
202 },
203 });
204 instance.update();
205 instance.destroy();
206 expect(isUpdateCalled).toBe(false);
207 });
208
209 describe('when boundariesElement is not `window` and the scroll parent is not `window`', () => {
210 it('removes the scroll event listener from the scroll parent', () => {
211 const boundariesElement = makeConnectedScrollElement();
212 const reference = boundariesElement.appendChild(makeElement());
213 const popper = boundariesElement.appendChild(makeElement());
214
215 spyOn(boundariesElement, 'removeEventListener');
216
217 const instance = new Popper(reference, popper, {
218 boundariesElement: boundariesElement,
219 });
220 const { updateBound } = instance.state;
221 instance.destroy();
222
223 expect(boundariesElement.removeEventListener.calls.allArgs()).toEqual([
224 ['scroll', updateBound],
225 ]);
226 });
227
228 describe('when the reference is disconnected from the DOM', () => {
229 it('removes the scroll event listener from the scroll parent when the reference is disconnected from the DOM', () => {
230 const boundariesElement = makeConnectedScrollElement();
231 const reference = boundariesElement.appendChild(makeElement());
232 const popper = boundariesElement.appendChild(makeElement());
233
234 spyOn(boundariesElement, 'removeEventListener');
235
236 const instance = new Popper(reference, popper, {
237 boundariesElement: boundariesElement,
238 });
239 const { updateBound } = instance.state;
240
241 boundariesElement.removeChild(reference);
242 instance.destroy();
243
244 expect(
245 boundariesElement.removeEventListener.calls.allArgs()
246 ).toEqual([['scroll', updateBound]]);
247 });
248 });
249 });
250 });
251
252 describe('methods: enableEventListeners/disableEventListeners', () => {
253 it('enableEventListeners', () => {
254 spyOn(window, 'addEventListener');
255 const instance = makePopper(
256 makeConnectedElement(),
257 makeConnectedElement(),
258 { eventsEnabled: false }
259 );
260
261 instance.enableEventListeners();
262 expect(window.addEventListener.calls.count()).toEqual(2);
263 expect(window.addEventListener.calls.argsFor(0)).toEqual([
264 'resize',
265 instance.state.updateBound,
266 { passive: true },
267 ]);
268 expect(window.addEventListener.calls.argsFor(1)).toEqual([
269 'scroll',
270 instance.state.updateBound,
271 { passive: true },
272 ]);
273 expect(instance.state.eventsEnabled).toBe(true);
274 });
275
276 it('disableEventListeners', () => {
277 spyOn(window, 'removeEventListener');
278 const instance = makePopper(
279 makeConnectedElement(),
280 makeConnectedElement()
281 );
282 const { updateBound } = instance.state;
283
284 instance.disableEventListeners();
285 expect(window.removeEventListener.calls.argsFor(0)).toEqual([
286 'resize',
287 updateBound,
288 ]);
289 expect(window.removeEventListener.calls.argsFor(1)).toEqual([
290 'scroll',
291 updateBound,
292 ]);
293 expect(instance.state.eventsEnabled).toBe(false);
294 expect(instance.state.updateBound).toBe(null);
295 expect(instance.state.scrollElement).toBe(null);
296 });
297 });
298 });
299 });