Skip to content

Commit 6c1ed8a

Browse files
authored
test: refactor and simplify vaadin-overlay renderer tests (#6045)
1 parent 76a29c7 commit 6c1ed8a

1 file changed

Lines changed: 134 additions & 104 deletions

File tree

Lines changed: 134 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -1,114 +1,144 @@
11
import { expect } from '@esm-bundle/chai';
2-
import { fixtureSync } from '@vaadin/testing-helpers';
2+
import { fixtureSync, nextRender } from '@vaadin/testing-helpers';
33
import sinon from 'sinon';
44
import '../vaadin-overlay.js';
55

66
describe('renderer', () => {
7-
let rendererContent, renderModel;
7+
let overlay, content;
88

9-
beforeEach(() => {
10-
rendererContent = document.createElement('p');
11-
rendererContent.textContent = 'renderer-content';
12-
renderModel = { selected: true };
9+
beforeEach(async () => {
10+
overlay = fixtureSync('<vaadin-overlay></vaadin-overlay>');
11+
await nextRender();
12+
content = document.createElement('p');
13+
content.textContent = 'renderer-content';
1314
});
1415

15-
describe('without overlay', () => {
16-
let overlay;
17-
18-
beforeEach(() => {
19-
overlay = fixtureSync('<vaadin-overlay></vaadin-overlay>');
20-
});
21-
22-
afterEach(() => {
23-
overlay.opened = false;
24-
});
25-
26-
it('should use renderer when it is defined', () => {
27-
overlay.renderer = (root) => root.appendChild(rendererContent);
28-
overlay.opened = true;
29-
expect(overlay.textContent.trim()).to.equal('renderer-content');
30-
});
31-
32-
it('should receive empty root, model and owner when it is defined', () => {
33-
const overlayOwner = {};
34-
overlay.owner = overlayOwner;
35-
overlay.model = renderModel;
36-
overlay.renderer = (root, owner, model) => {
37-
expect(root.firstChild).to.be.null;
38-
expect(owner).to.eql(overlayOwner);
39-
expect(model).to.eql(renderModel);
40-
};
41-
});
42-
43-
it('should clean the root on renderer changed', () => {
44-
overlay.renderer = (root) => root.appendChild(rendererContent);
45-
overlay.opened = true;
46-
expect(overlay.textContent.trim()).to.equal('renderer-content');
47-
overlay.renderer = (root) => expect(root.firstChild).to.be.null;
48-
});
49-
50-
it('should not clean the root on model or owner changed', () => {
51-
overlay.renderer = (root, owner, model) => {
52-
if (owner !== undefined || model !== undefined) {
53-
expect(root.firstChild).not.to.be.null;
54-
}
55-
root.appendChild(rendererContent);
56-
};
57-
const overlayOwner = {};
58-
overlay.owner = overlayOwner;
59-
overlay.model = renderModel;
60-
});
61-
62-
it('should pass owner as this to the renderer', () => {
63-
overlay.owner = {};
64-
overlay.model = renderModel;
65-
overlay.renderer = function (root, owner) {
66-
expect(this).to.eql(owner);
67-
};
68-
});
69-
70-
it('should call renderer on model change', () => {
71-
const spy = sinon.spy();
72-
overlay.opened = true;
73-
overlay.renderer = () => spy();
74-
spy.resetHistory();
75-
overlay.model = {};
76-
expect(spy.calledOnce).to.be.true;
77-
});
78-
79-
it('should call renderer on owner change', () => {
80-
const spy = sinon.spy();
81-
overlay.opened = true;
82-
overlay.renderer = () => spy();
83-
spy.resetHistory();
84-
overlay.owner = {};
85-
expect(spy.calledOnce).to.be.true;
86-
});
87-
88-
it('should run renderers when requesting content update', () => {
89-
overlay.renderer = sinon.spy();
90-
overlay.requestContentUpdate();
91-
92-
expect(overlay.renderer.calledOnce).to.be.true;
93-
});
94-
95-
it('should not render if overlay is not open', () => {
96-
const spy = sinon.spy();
97-
overlay.renderer = () => spy();
98-
expect(spy.called).to.be.false;
99-
});
100-
101-
it('should clear the content when removing the renderer', () => {
102-
overlay.renderer = (root) => {
103-
root.innerHTML = 'foo';
104-
};
105-
overlay.opened = true;
106-
107-
expect(overlay.textContent.trim()).to.equal('foo');
108-
109-
overlay.renderer = null;
110-
111-
expect(overlay.textContent.trim()).to.equal('');
112-
});
16+
afterEach(async () => {
17+
overlay.opened = false;
18+
await nextRender();
19+
});
20+
21+
it('should use renderer when it is defined', async () => {
22+
overlay.renderer = (root) => root.appendChild(content);
23+
overlay.opened = true;
24+
await nextRender();
25+
expect(overlay.textContent.trim()).to.equal('renderer-content');
26+
});
27+
28+
it('should receive empty root, model and owner when they are defined', async () => {
29+
const overlayOwner = {};
30+
const overlayModel = {};
31+
32+
overlay.owner = overlayOwner;
33+
overlay.model = overlayModel;
34+
35+
const renderer = sinon.spy();
36+
37+
overlay.renderer = renderer;
38+
overlay.opened = true;
39+
await nextRender();
40+
41+
const [root, owner, model] = renderer.firstCall.args;
42+
expect(root.firstChild).to.be.null;
43+
expect(owner).to.eql(overlayOwner);
44+
expect(model).to.eql(overlayModel);
45+
});
46+
47+
it('should clean the root on renderer change', async () => {
48+
overlay.renderer = (root) => root.appendChild(content);
49+
overlay.opened = true;
50+
await nextRender();
51+
expect(overlay.textContent.trim()).to.equal('renderer-content');
52+
53+
const renderer = sinon.spy();
54+
overlay.renderer = renderer;
55+
await nextRender();
56+
57+
const root = renderer.firstCall.args[0];
58+
expect(root.firstChild).to.be.null;
59+
});
60+
61+
it('should not clean the root on model or owner change', async () => {
62+
overlay.renderer = (root) => root.appendChild(content);
63+
overlay.opened = true;
64+
await nextRender();
65+
expect(overlay.textContent.trim()).to.equal('renderer-content');
66+
67+
const overlayOwner = {};
68+
const overlayModel = {};
69+
70+
overlay.owner = overlayOwner;
71+
overlay.model = overlayModel;
72+
await nextRender();
73+
74+
expect(overlay.textContent.trim()).to.equal('renderer-content');
75+
});
76+
77+
it('should pass owner as this to the renderer', async () => {
78+
const owner = {};
79+
overlay.owner = owner;
80+
81+
const renderer = sinon.spy();
82+
overlay.renderer = renderer;
83+
84+
overlay.opened = true;
85+
await nextRender();
86+
87+
expect(renderer.firstCall.thisValue).to.equal(owner);
88+
});
89+
90+
it('should call renderer on model change', async () => {
91+
const renderer = sinon.spy();
92+
93+
overlay.opened = true;
94+
overlay.renderer = renderer;
95+
await nextRender();
96+
97+
renderer.resetHistory();
98+
overlay.model = {};
99+
await nextRender();
100+
101+
expect(renderer.calledOnce).to.be.true;
102+
});
103+
104+
it('should call renderer on owner change', async () => {
105+
const renderer = sinon.spy();
106+
107+
overlay.opened = true;
108+
overlay.renderer = renderer;
109+
await nextRender();
110+
111+
renderer.resetHistory();
112+
overlay.owner = {};
113+
await nextRender();
114+
115+
expect(renderer.calledOnce).to.be.true;
116+
});
117+
118+
it('should call renderer when requesting content update', () => {
119+
overlay.renderer = sinon.spy();
120+
overlay.requestContentUpdate();
121+
122+
expect(overlay.renderer.calledOnce).to.be.true;
123+
});
124+
125+
it('should not call renderer if overlay is not open', async () => {
126+
overlay.renderer = sinon.spy();
127+
await nextRender();
128+
expect(overlay.renderer.called).to.be.false;
129+
});
130+
131+
it('should clear the content when removing the renderer', async () => {
132+
overlay.renderer = (root) => {
133+
root.innerHTML = 'foo';
134+
};
135+
136+
overlay.opened = true;
137+
await nextRender();
138+
expect(overlay.textContent.trim()).to.equal('foo');
139+
140+
overlay.renderer = null;
141+
await nextRender();
142+
expect(overlay.textContent.trim()).to.equal('');
113143
});
114144
});

0 commit comments

Comments
 (0)