![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: EMFFormsRevealServiceImpl_ITest$3
EMFFormsRevealServiceImpl_ITest$3
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| reveal(VElement, EObject) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2019 Christian W. Damus and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Christian W. Damus - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emfforms.internal.core.services.reveal;
15:
16: import static org.eclipse.emf.ecp.view.test.common.spi.EMFFormsRevealServiceFixture.isA;
17: import static org.eclipse.emf.ecp.view.test.common.spi.EMFFormsRevealServiceFixture.isListOf;
18: import static org.eclipse.emf.ecp.view.test.common.spi.EMFFormsRevealServiceFixture.pass;
19: import static org.eclipse.emf.ecp.view.test.common.spi.EMFMocking.eMock;
20: import static org.hamcrest.CoreMatchers.both;
21: import static org.hamcrest.CoreMatchers.hasItems;
22: import static org.hamcrest.CoreMatchers.instanceOf;
23: import static org.hamcrest.CoreMatchers.is;
24: import static org.hamcrest.CoreMatchers.not;
25: import static org.hamcrest.CoreMatchers.notNullValue;
26: import static org.hamcrest.CoreMatchers.sameInstance;
27: import static org.junit.Assert.assertThat;
28: import static org.mockito.Mockito.inOrder;
29: import static org.mockito.Mockito.mock;
30: import static org.mockito.Mockito.never;
31: import static org.mockito.Mockito.verify;
32:
33: import java.util.ArrayList;
34: import java.util.Collections;
35: import java.util.List;
36:
37: import org.eclipse.emf.ecore.EObject;
38: import org.eclipse.emf.ecp.view.spi.model.VControl;
39: import org.eclipse.emf.ecp.view.spi.model.VElement;
40: import org.eclipse.emf.ecp.view.test.common.spi.EMFFormsRevealServiceFixture;
41: import org.eclipse.emf.ecp.view.test.common.spi.EMFFormsRevealServiceFixture.TestProvider;
42: import org.eclipse.emf.ecp.view.test.common.spi.EMFFormsViewContextFixture.DomainModel;
43: import org.eclipse.emf.ecp.view.test.common.spi.EMFFormsViewContextFixture.ViewModel;
44: import org.eclipse.emf.ecp.view.test.common.spi.EMFMockingRunner;
45: import org.eclipse.emf.ecp.view.test.common.spi.EMock;
46: import org.eclipse.emfforms.bazaar.Bid;
47: import org.eclipse.emfforms.bazaar.Create;
48: import org.eclipse.emfforms.spi.core.services.reveal.DrillDown;
49: import org.eclipse.emfforms.spi.core.services.reveal.DrillUp;
50: import org.eclipse.emfforms.spi.core.services.reveal.EMFFormsRevealProvider;
51: import org.eclipse.emfforms.spi.core.services.reveal.Reveal;
52: import org.eclipse.emfforms.spi.core.services.reveal.RevealHelper;
53: import org.eclipse.emfforms.spi.core.services.reveal.RevealStep;
54: import org.eclipse.emfforms.spi.core.services.reveal.RevealStepKind;
55: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewContext;
56: import org.junit.Rule;
57: import org.junit.Test;
58: import org.junit.runner.RunWith;
59: import org.mockito.InOrder;
60:
61: /**
62: * Integration tests covering the {@link EMFFormsRevealServiceImpl} class.
63: */
64: @SuppressWarnings("nls")
65: @RunWith(EMFMockingRunner.class)
66: public class EMFFormsRevealServiceImpl_ITest {
67:
68: @EMock
69: @ViewModel
70: private VControl control;
71:
72: @EMock
73: @DomainModel
74: private EObject domainModelRoot;
75:
76: @EMock
77: private EObject object;
78:
79: @Rule
80: public final EMFFormsRevealServiceFixture<EMFFormsViewContext> fixture = EMFFormsRevealServiceFixture.create(this);
81:
82: /**
83: * Initializes me.
84: */
85: public EMFFormsRevealServiceImpl_ITest() {
86: super();
87: }
88:
89: @Test
90: public void reveal_noProviders() {
91: assertThat("Should have failed to reveal", fixture.reveal(object), is(false));
92: assertThat("Shoudl be a failure step", fixture.reveal(object, control), isA(RevealStepKind.FAILED));
93: }
94:
95: @SuppressWarnings("unchecked")
96: @Test
97: public void provider_injection() {
98: final List<Object> injectedIntoBid = new ArrayList<>(2);
99: final List<Object> injectedIntoCreate = new ArrayList<>(3);
100:
101: final EMFFormsRevealProvider provider = new EMFFormsRevealProvider() {
102: @Bid
103: double bid(VElement viewModel, EObject domainModel) {
104: injectedIntoBid.add(viewModel);
105: injectedIntoBid.add(domainModel);
106: return 1.0;
107: }
108:
109: @Create
110: RevealStep create(VElement viewModel, EObject domainModel, RevealHelper helper) {
111: injectedIntoCreate.add(viewModel);
112: injectedIntoCreate.add(domainModel);
113: injectedIntoCreate.add(helper);
114: return RevealStep.reveal(viewModel, domainModel, pass());
115: }
116: };
117:
118: fixture.addRevealProvider(provider);
119: fixture.reveal(object);
120:
121: assertThat(injectedIntoBid, isListOf(control, object));
122: assertThat(injectedIntoCreate,
123: hasItems(sameInstance(control), sameInstance(object), instanceOf(RevealHelperImpl.class)));
124: }
125:
126: @Test
127: public void terminalStep() {
128: final Runnable reveal = mock(Runnable.class, "reveal");
129:
130: final EMFFormsRevealProvider provider = new TestProvider() {
131: @Create
132: RevealStep create(VElement viewModel, EObject domainModel) {
133: return RevealStep.reveal(viewModel, domainModel, reveal);
134: }
135: };
136:
137: fixture.addRevealProvider(provider);
138:
139: final boolean revealed = fixture.reveal(object);
140:
141: assertThat("Not revealed", revealed, is(true));
142: verify(reveal).run();
143: }
144:
145: @Test
146: public void helper_defer() {
147: final Runnable reveal = mock(Runnable.class, "reveal");
148:
149: final Object revealer = new Object() {
150: @Reveal
151: public RevealStep reveal(VElement viewModel, EObject domainModel) {
152: return RevealStep.reveal(viewModel, domainModel, reveal);
153: }
154: };
155:
156: final EMFFormsRevealProvider provider = new TestProvider() {
157: @Create
158: RevealStep create(VElement viewModel, EObject domainModel, RevealHelper helper) {
159: return helper.defer(revealer);
160: }
161: };
162:
163: fixture.addRevealProvider(provider);
164:
165: final RevealStep deferredStep = fixture.reveal(object, control);
166:
167: // It's deferred; that's the point
168: verify(reveal, never()).run();
169:
170: assertThat(deferredStep, isA(RevealStepKind.TERMINAL));
171: assertThat(deferredStep.getViewModel(), is(control));
172: assertThat(deferredStep.getDomainModel(), is(object));
173:
174: deferredStep.reveal();
175:
176: verify(reveal).run();
177: }
178:
179: @Test
180: public void helper_drillDown_internal() {
181: final Runnable outerReveal = mock(Runnable.class, "outerReveal");
182: final Runnable innerReveal = mock(Runnable.class, "innerReveal");
183:
184: configureDrillDown(outerReveal, innerReveal);
185: final RevealStep deferredStep = fixture.reveal(object, control);
186:
187: // They're deferred; that's the point
188: verify(outerReveal, never()).run();
189: verify(innerReveal, never()).run();
190:
191: assertThat(deferredStep, isA(RevealStepKind.INTERMEDIATE));
192: assertThat(deferredStep.getViewModel(), is(control));
193: assertThat(deferredStep.getDomainModel(), is(domainModelRoot));
194: final RevealStep next = deferredStep.drillDown();
195:
196: assertThat(next, isA(RevealStepKind.TERMINAL));
197: assertThat("Should have revealed in the child control", next.getViewModel(),
198: both(not((VElement) control)).and(notNullValue()));
199: next.reveal();
200:
201: final InOrder inOrder = inOrder(outerReveal, innerReveal);
202: inOrder.verify(outerReveal).run();
203: inOrder.verify(innerReveal).run();
204:
205: assertThat("Another computation performed", deferredStep.drillDown(), sameInstance(next));
206: }
207:
208: private void configureDrillDown(Runnable outerReveal, Runnable innerReveal) {
209: final List<VControl> children = Collections.singletonList(eMock(VControl.class, "childControl"));
210:
211: final Object computation = new Object() {
212: @DrillDown
213: public List<VControl> drillDown(EObject parent) {
214: return children;
215: }
216:
217: @Reveal
218: public RevealStep reveal(VElement viewModel, EObject domainModel, RevealStep nextStep) {
219: return RevealStep.reveal(nextStep.getViewModel(), domainModel, outerReveal);
220: }
221: };
222:
223: final EMFFormsRevealProvider provider = new TestProvider() {
224: @Create
225: RevealStep create(VElement viewModel, EObject domainModel, RevealHelper helper) {
226: return viewModel == control
227: ? helper.drillDown(computation, computation)
228: : RevealStep.reveal(viewModel, domainModel, innerReveal);
229: }
230: };
231:
232: fixture.addRevealProvider(provider);
233: }
234:
235: @Test
236: public void helper_drillDown_external() {
237: final Runnable outerReveal = mock(Runnable.class, "outerReveal");
238: final Runnable innerReveal = mock(Runnable.class, "innerReveal");
239:
240: configureDrillDown(outerReveal, innerReveal);
241: fixture.reveal(object);
242:
243: final InOrder inOrder = inOrder(outerReveal, innerReveal);
244: inOrder.verify(outerReveal).run();
245: inOrder.verify(innerReveal).run();
246: }
247:
248: @Test
249: public void helper_masterDetail_internal() {
250: final Runnable masterReveal = mock(Runnable.class, "masterReveal");
251: final Runnable detailReveal = mock(Runnable.class, "detailReveal");
252: final EObject detail = eMock(EObject.class, "detail");
253:
254: configureMasterDetail(detail, masterReveal, detailReveal);
255: final RevealStep deferredStep = fixture.reveal(detail, control);
256:
257: // They're deferred; that's the point
258: verify(masterReveal, never()).run();
259: verify(detailReveal, never()).run();
260:
261: assertThat(deferredStep, isA(RevealStepKind.INTERMEDIATE));
262: assertThat(deferredStep.getViewModel(), is(control));
263: // assertThat(deferredStep.getDomainModel(), is(object));
264: final RevealStep next = deferredStep.drillDown();
265:
266: assertThat(next, isA(RevealStepKind.TERMINAL));
267: assertThat("Should have revealed in the detail control", next.getViewModel(),
268: both(not((VElement) control)).and(notNullValue()));
269: assertThat(deferredStep.getDomainModel(), is(detail));
270: next.reveal();
271:
272: final InOrder inOrder = inOrder(masterReveal, detailReveal);
273: inOrder.verify(masterReveal).run();
274: inOrder.verify(detailReveal).run();
275:
276: assertThat("Another computation performed", deferredStep.drillDown(), sameInstance(next));
277: }
278:
279: private void configureMasterDetail(EObject detail, Runnable masterReveal, Runnable detailReveal) {
280: final VControl detailView = eMock(VControl.class, "detailView");
281:
282: final Object computation = new Object() {
283: @DrillUp
284: public EObject getMaster(EObject eObject) {
285: return eObject == detail ? object : eObject;
286: }
287:
288: @Reveal
289: public RevealStep reveal(VElement viewModel, EObject domainModel) {
290: return RevealStep.reveal(viewModel, domainModel, masterReveal);
291: }
292: };
293:
294: final EMFFormsRevealProvider provider = new TestProvider() {
295: @Create
296: RevealStep create(VElement viewModel, EObject domainModel, RevealHelper helper) {
297: return viewModel == control
298: ? helper.masterDetail(computation, computation)
299: : RevealStep.reveal(viewModel, domainModel, detailReveal);
300: }
301: };
302:
303: // Supply the child context for the detail view of the master selection,
304: // which is the 'object', the bespoke parent of the 'detail' object that
305: // we are revealing
306: fixture.createChildContext(control, "childContext", detailView, object);
307:
308: fixture.addRevealProvider(provider);
309: }
310:
311: @Test
312: public void helper_masterDetail_external() {
313: final Runnable masterReveal = mock(Runnable.class, "masterReveal");
314: final Runnable detailReveal = mock(Runnable.class, "detailReveal");
315: final EObject detail = eMock(EObject.class, "detail");
316:
317: configureMasterDetail(detail, masterReveal, detailReveal);
318: fixture.reveal(detail);
319:
320: final InOrder inOrder = inOrder(masterReveal, detailReveal);
321: inOrder.verify(masterReveal).run();
322: inOrder.verify(detailReveal).run();
323: }
324:
325: }