![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: TemplateCreateNewModelElementStrategyProvider_Test$RegexFilterService
TemplateCreateNewModelElementStrategyProvider_Test$RegexFilterService
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| TemplateCreateNewModelElementStrategyProvider_Test.RegexFilterService() |
|
|
|
|
|
||||||||||||||||||||
| getTemplateFilter(EObject, EReference) |
|
|
|
|
|
||||||||||||||||||||
| lambda$0(Template) |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH 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: * Lucas Koehler - initial API and implementation
13: * Christian W. Damus - bugs 543461, 546974
14: ******************************************************************************/
15: package org.eclipse.emfforms.internal.core.services.datatemplate;
16:
17: import static org.hamcrest.CoreMatchers.anything;
18: import static org.hamcrest.CoreMatchers.both;
19: import static org.hamcrest.CoreMatchers.hasItem;
20: import static org.hamcrest.CoreMatchers.hasItems;
21: import static org.hamcrest.CoreMatchers.instanceOf;
22: import static org.hamcrest.CoreMatchers.is;
23: import static org.hamcrest.CoreMatchers.not;
24: import static org.hamcrest.CoreMatchers.notNullValue;
25: import static org.junit.Assert.assertEquals;
26: import static org.junit.Assert.assertFalse;
27: import static org.junit.Assert.assertNotNull;
28: import static org.junit.Assert.assertThat;
29: import static org.junit.Assert.assertTrue;
30: import static org.mockito.Matchers.any;
31: import static org.mockito.Matchers.anySetOf;
32: import static org.mockito.Matchers.same;
33: import static org.mockito.Mockito.doReturn;
34: import static org.mockito.Mockito.inOrder;
35: import static org.mockito.Mockito.mock;
36: import static org.mockito.Mockito.spy;
37: import static org.mockito.Mockito.times;
38: import static org.mockito.Mockito.verify;
39: import static org.mockito.Mockito.when;
40:
41: import java.util.Arrays;
42: import java.util.Collection;
43: import java.util.Hashtable;
44: import java.util.LinkedHashSet;
45: import java.util.Set;
46: import java.util.function.Predicate;
47:
48: import org.eclipse.emf.ecore.EClass;
49: import org.eclipse.emf.ecore.EDataType;
50: import org.eclipse.emf.ecore.EEnum;
51: import org.eclipse.emf.ecore.EObject;
52: import org.eclipse.emf.ecore.EReference;
53: import org.eclipse.emf.ecore.EcoreFactory;
54: import org.eclipse.emf.ecore.EcorePackage;
55: import org.eclipse.emf.ecore.util.EcoreUtil;
56: import org.eclipse.emf.ecp.common.spi.Labelizer;
57: import org.eclipse.emf.ecp.ui.view.swt.reference.CreateNewModelElementStrategy;
58: import org.eclipse.emf.ecp.ui.view.swt.reference.EClassSelectionStrategy;
59: import org.eclipse.emfforms.bazaar.Bid;
60: import org.eclipse.emfforms.bazaar.Create;
61: import org.eclipse.emfforms.bazaar.StaticBid;
62: import org.eclipse.emfforms.common.Optional;
63: import org.eclipse.emfforms.core.services.datatemplate.TemplateFilterService;
64: import org.eclipse.emfforms.core.services.datatemplate.TemplateProvider;
65: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.AdminUser;
66: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.AuditFactory;
67: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.AuditPackage;
68: import org.eclipse.emfforms.datatemplate.DataTemplateFactory;
69: import org.eclipse.emfforms.datatemplate.Template;
70: import org.hamcrest.CustomTypeSafeMatcher;
71: import org.hamcrest.Matcher;
72: import org.junit.Before;
73: import org.junit.Test;
74: import org.mockito.InOrder;
75: import org.mockito.Matchers;
76: import org.mockito.Mockito;
77: import org.mockito.invocation.InvocationOnMock;
78: import org.mockito.stubbing.Answer;
79: import org.osgi.service.component.ComponentContext;
80:
81: /**
82: * Test cases for the TemplateCreateNewModelElementStrategyProvider and its provided strategy.
83: *
84: * @author Lucas Koehler
85: *
86: */
87: public class TemplateCreateNewModelElementStrategyProvider_Test {
88:
89: private TemplateCreateNewModelElementStrategyProvider strategyProvider;
90:
91: /**
92: * @throws java.lang.Exception
93: */
94: @Before
95: public void setUp() throws Exception {
96: final ComponentContext context = mock(ComponentContext.class);
97: when(context.getProperties()).thenReturn(new Hashtable<>());
98:
99: strategyProvider = new TemplateCreateNewModelElementStrategyProvider();
100: strategyProvider.activate(context);
101: }
102:
103: @Test
104: public void testHandles_availableTemplates() {
105: final TemplateProvider canProvide = mock(TemplateProvider.class);
106: when(canProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(true);
107:
108: final TemplateProvider cannotProvide = mock(TemplateProvider.class);
109: when(cannotProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(false);
110: strategyProvider.registerTemplateProvider(canProvide);
111: strategyProvider.registerTemplateProvider(cannotProvide);
112:
113: final EObject eObject = mock(EObject.class);
114: final EReference eReference = mock(EReference.class);
115: assertTrue(strategyProvider.handles(eObject, eReference));
116: final InOrder inOrder = Mockito.inOrder(canProvide, cannotProvide);
117: inOrder.verify(canProvide, Mockito.times(1)).canProvideTemplates(any(EObject.class), any(EReference.class));
118: inOrder.verify(cannotProvide, Mockito.never()).canProvideTemplates(any(EObject.class), any(EReference.class));
119: }
120:
121: @Test
122: public void testHandles_noAvailableTemplates() {
123: final TemplateProvider cannotProvide = mock(TemplateProvider.class);
124: when(cannotProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(false);
125: strategyProvider.registerTemplateProvider(cannotProvide);
126:
127: final EObject eObject = mock(EObject.class);
128: final EReference eReference = mock(EReference.class);
129: assertFalse(strategyProvider.handles(eObject, eReference));
130: }
131:
132: @Test
133: public void testCollectAvailableTemplates() {
134: final TemplateProvider canProvide = mock(TemplateProvider.class);
135: when(canProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(true);
136: final LinkedHashSet<Template> canProvideTemplates = new LinkedHashSet<Template>(2);
137: final Template template = mock(Template.class);
138: canProvideTemplates.add(template);
139: when(canProvide.provideTemplates(any(EObject.class), any(EReference.class))).thenReturn(canProvideTemplates);
140:
141: final TemplateProvider cannotProvide = mock(TemplateProvider.class);
142: when(cannotProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(false);
143: strategyProvider.registerTemplateProvider(canProvide);
144: strategyProvider.registerTemplateProvider(cannotProvide);
145:
146: final EObject eObject = mock(EObject.class);
147: final EReference eReference = mock(EReference.class);
148: final Set<Template> templates = strategyProvider.collectAvailableTemplates(eObject, eReference);
149:
150: assertEquals(1, templates.size());
151: assertTrue(templates.contains(template));
152:
153: final InOrder canProvideOrder = inOrder(canProvide);
154: canProvideOrder.verify(canProvide).canProvideTemplates(same(eObject), same(eReference));
155: canProvideOrder.verify(canProvide).provideTemplates(same(eObject), same(eReference));
156: verify(cannotProvide).canProvideTemplates(same(eObject), same(eReference));
157: verify(cannotProvide, times(0)).provideTemplates(same(eObject), same(eReference));
158: }
159:
160: /**
161: * Test creation of the strategy and its implementation of consistency of classes
162: * presented to the user with available templates.
163: *
164: * @see <a href="http://eclip.se/543461">bug 543461</a>
165: */
166: @Test
167: public void testCreateNewModelElementStrategy() {
168: final TemplateProvider provider = mock(TemplateProvider.class);
169: when(provider.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(true);
170:
171: final LinkedHashSet<Template> templates = new LinkedHashSet<Template>();
172: final EDataType datatype = EcoreFactory.eINSTANCE.createEDataType();
173: datatype.setName("Date"); //$NON-NLS-1$
174: final Template dtTemplate = DataTemplateFactory.eINSTANCE.createTemplate();
175: dtTemplate.setInstance(datatype);
176: dtTemplate.setName("Example DataType"); //$NON-NLS-1$
177: templates.add(dtTemplate);
178: final EEnum enum_ = EcoreFactory.eINSTANCE.createEEnum();
179: enum_.setName("YesNo"); //$NON-NLS-1$
180: final Template enTemplate = DataTemplateFactory.eINSTANCE.createTemplate();
181: enTemplate.setInstance(enum_);
182: enTemplate.setName("Example Enum"); //$NON-NLS-1$
183: templates.add(enTemplate);
184: when(provider.provideTemplates(any(EObject.class), any(EReference.class))).thenReturn(templates);
185: strategyProvider.registerTemplateProvider(provider);
186:
187: final ComponentContext componentContext = mock(ComponentContext.class);
188: when(componentContext.getProperties()).thenReturn(new Hashtable<String, Object>());
189:
190: strategyProvider.activate(componentContext);
191:
192: final CreateNewModelElementStrategy strategy = strategyProvider.createCreateNewModelElementStrategy();
193: assertThat(strategy, instanceOf(TemplateCreateNewModelElementStrategyProvider.Strategy.class));
194:
195: // Spy on the implementation to verify internals
196: final TemplateCreateNewModelElementStrategyProvider.Strategy spy = spy(
197: (TemplateCreateNewModelElementStrategyProvider.Strategy) strategy);
198:
199: // Mustn't actually try to show a wizard dialog
200: doReturn(Optional.of(dtTemplate)).when(spy)
201: .showSelectModelInstancesDialog(anySetOf(EClass.class), anySetOf(Template.class));
202:
203: final Optional<EObject> created = spy.createNewModelElement(AuditPackage.eINSTANCE,
204: EcorePackage.Literals.EPACKAGE__ECLASSIFIERS);
205: assertThat("Nothing created", created.isPresent(), is(true)); //$NON-NLS-1$
206: assertThat("Wrong thing created", created.get(), eEqualTo(datatype)); //$NON-NLS-1$
207:
208: // Verify invocation of the wizard, that it didn't offer classes for which there
209: // weren't any templates
210: final Set<EClass> subClasses = new LinkedHashSet<>();
211: subClasses.add(EcorePackage.Literals.EDATA_TYPE);
212: subClasses.add(EcorePackage.Literals.EENUM);
213: // not EcorePackage.Literals.ECLASS
214: Mockito.verify(spy).showSelectModelInstancesDialog(subClasses, templates);
215: }
216:
217: @Test
218: public void testStrategy() {
219: final ComponentContext componentContext = mock(ComponentContext.class);
220: when(componentContext.getProperties()).thenReturn(new Hashtable<String, Object>());
221: strategyProvider.activate(componentContext);
222:
223: final TemplateProvider canProvide = mock(TemplateProvider.class);
224: when(canProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(true);
225: final LinkedHashSet<Template> canProvideTemplates = new LinkedHashSet<Template>(2);
226: final Template template = DataTemplateFactory.eINSTANCE.createTemplate();
227: final AdminUser adminUser = AuditFactory.eINSTANCE.createAdminUser();
228: adminUser.setDisplayName("Test"); //$NON-NLS-1$
229: template.setInstance(adminUser);
230: canProvideTemplates.add(template);
231: when(canProvide.provideTemplates(any(EObject.class), any(EReference.class))).thenReturn(canProvideTemplates);
232: strategyProvider.registerTemplateProvider(canProvide);
233:
234: final EClassSelectionStrategy selectionStrategy = mock(EClassSelectionStrategy.class);
235: when(selectionStrategy.collectEClasses(any(EObject.class), any(EReference.class),
236: Matchers.<Collection<EClass>> any())).then(new Answer<Collection<EClass>>() {
237:
238: @SuppressWarnings("unchecked")
239: @Override
240: public Collection<EClass> answer(InvocationOnMock invocation) throws Throwable {
241: return (Collection<EClass>) invocation.getArguments()[2];
242: }
243:
244: });
245: strategyProvider
246: .addEClassSelectionStrategyProvider(new TestEClassSelectionStrategyProvider(1d, selectionStrategy));
247:
248: final CreateNewModelElementStrategy strategy = strategyProvider.createCreateNewModelElementStrategy();
249:
250: final EObject owner = AuditFactory.eINSTANCE.createUserGroup();
251: final EReference reference = AuditPackage.Literals.USER_GROUP__ADMINS;
252: final Optional<EObject> resultOptional = strategy.createNewModelElement(owner, reference);
253:
254: assertTrue(resultOptional.isPresent());
255: assertTrue(resultOptional.get() instanceof AdminUser);
256: final AdminUser createdElement = (AdminUser) resultOptional.get();
257: assertEquals(adminUser.getDisplayName(), createdElement.getDisplayName());
258:
259: verify(selectionStrategy).collectEClasses(same(owner), same(reference), Matchers.<Collection<EClass>> any());
260: }
261:
262: @Test
263: public void testStrategyNoAvailableTemplate() {
264: final ComponentContext componentContext = mock(ComponentContext.class);
265: when(componentContext.getProperties()).thenReturn(new Hashtable<String, Object>());
266: strategyProvider.activate(componentContext);
267:
268: final TemplateProvider canProvide = mock(TemplateProvider.class);
269: when(canProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(false);
270: strategyProvider.registerTemplateProvider(canProvide);
271:
272: final EClassSelectionStrategy selectionStrategy = mock(EClassSelectionStrategy.class);
273: strategyProvider
274: .addEClassSelectionStrategyProvider(new TestEClassSelectionStrategyProvider(1d, selectionStrategy));
275:
276: final CreateNewModelElementStrategy strategy = strategyProvider.createCreateNewModelElementStrategy();
277:
278: final EObject owner = mock(EObject.class);
279: final EReference reference = mock(EReference.class);
280: final Optional<EObject> resultOptional = strategy.createNewModelElement(owner, reference);
281:
282: assertNotNull(resultOptional);
283: assertFalse(resultOptional.isPresent());
284:
285: verify(selectionStrategy, times(0)).collectEClasses(any(EObject.class), any(EReference.class),
286: Matchers.<Collection<EClass>> any());
287: }
288:
289: @SuppressWarnings("nls")
290: @Test
291: public void testTemplateFilters() {
292: final TemplateProvider canProvide = mock(TemplateProvider.class);
293: when(canProvide.canProvideTemplates(any(EObject.class), any(EReference.class))).thenReturn(true);
294: final Template template1 = mock(Template.class);
295: when(template1.getName()).thenReturn("First Template");
296: final Template template2 = mock(Template.class);
297: when(template2.getName()).thenReturn("Second Template");
298: final Template template3 = mock(Template.class);
299: when(template3.getName()).thenReturn("Third Template");
300: final Set<Template> canProvideTemplates = new LinkedHashSet<>(Arrays.asList(template1, template2, template3));
301: when(canProvide.provideTemplates(any(EObject.class), any(EReference.class))).thenReturn(canProvideTemplates);
302: strategyProvider.registerTemplateProvider(canProvide);
303:
304: final RegexFilterService.Provider filter1 = new RegexFilterService.Provider("^Template$");
305: final RegexFilterService.Provider filter2 = new RegexFilterService.Provider("^\\w{5} .+$");
306: strategyProvider.addFilterServiceProvider(filter1);
307: strategyProvider.addFilterServiceProvider(filter2);
308:
309: final EObject eObject = mock(EObject.class);
310: final EReference eReference = mock(EReference.class);
311: Set<Template> templates = strategyProvider.collectAvailableTemplates(eObject, eReference);
312:
313: assertThat("Filters should have excluded everything", templates, not(hasItem(anything())));
314:
315: filter1.setRegex("^.+ Template$");
316: templates = strategyProvider.collectAvailableTemplates(eObject, eReference);
317: assertThat("Filters should have excluded only Second Template", templates,
318: both(hasItems(template1, template3)).and(not(hasItem(template2))));
319:
320: strategyProvider.removeFilterServiceProvider(filter2);
321: templates = strategyProvider.collectAvailableTemplates(eObject, eReference);
322: assertThat("Filters should have excluded no templates", templates, hasItems(template1, template2, template3));
323: }
324:
325: //
326: // Test framework
327: //
328:
329: static class RegexFilterService implements TemplateFilterService {
330: private String regex;
331:
332: @Override
333: public Predicate<? super Template> getTemplateFilter(EObject owner, EReference reference) {
334: assertThat(owner, notNullValue());
335: assertThat(reference, notNullValue());
336:
337: return template -> //
338: template.getName().matches(regex);
339: }
340:
341: //
342: // Nested types
343: //
344:
345: @StaticBid(bid = 10.0)
346: static final class Provider implements TemplateFilterService.Provider {
347: private final RegexFilterService service = new RegexFilterService();
348:
349: Provider(String regex) {
350: super();
351:
352: setRegex(regex);
353: }
354:
355: void setRegex(String regex) {
356: service.regex = regex;
357: }
358:
359: @Create
360: public TemplateFilterService create() {
361: return service;
362: }
363:
364: }
365:
366: }
367:
368: class TestEClassSelectionStrategyProvider implements EClassSelectionStrategy.Provider {
369: private final Double bid;
370: private final EClassSelectionStrategy strategy;
371:
372: TestEClassSelectionStrategyProvider(Double bid, EClassSelectionStrategy strategy) {
373: super();
374:
375: this.bid = bid;
376: this.strategy = strategy;
377: }
378:
379: @Bid
380: public Double bid() {
381: return bid;
382: }
383:
384: @Create
385: public EClassSelectionStrategy create() {
386: return strategy;
387: }
388: }
389:
390: Matcher<EObject> eEqualTo(EObject other) {
391: return new CustomTypeSafeMatcher<EObject>("structurally equal to " + Labelizer.get(other).getLabel(other)) { //$NON-NLS-1$
392: @Override
393: protected boolean matchesSafely(EObject item) {
394: return EcoreUtil.equals(item, other);
395: }
396: };
397: }
398:
399: }