Skip to contentPackage: ValidationServiceImpl_Test$1
ValidationServiceImpl_Test$1
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2017 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.common.internal.validation;
15:
16: import static org.hamcrest.CoreMatchers.both;
17: import static org.hamcrest.CoreMatchers.containsString;
18: import static org.hamcrest.CoreMatchers.is;
19: import static org.hamcrest.CoreMatchers.not;
20: import static org.hamcrest.MatcherAssert.assertThat;
21: import static org.junit.Assert.assertEquals;
22: import static org.junit.Assert.assertSame;
23: import static org.junit.Assert.assertTrue;
24: import static org.junit.Assume.assumeThat;
25: import static org.mockito.Matchers.any;
26: import static org.mockito.Matchers.anyMapOf;
27: import static org.mockito.Mockito.mock;
28: import static org.mockito.Mockito.when;
29:
30: import java.util.Collections;
31: import java.util.IdentityHashMap;
32: import java.util.Set;
33:
34: import org.eclipse.emf.common.util.BasicDiagnostic;
35: import org.eclipse.emf.common.util.Diagnostic;
36: import org.eclipse.emf.common.util.DiagnosticChain;
37: import org.eclipse.emf.ecore.EAttribute;
38: import org.eclipse.emf.ecore.EClass;
39: import org.eclipse.emf.ecore.EObject;
40: import org.eclipse.emf.ecore.EPackage;
41: import org.eclipse.emf.ecore.EValidator;
42: import org.eclipse.emf.ecore.EValidator.SubstitutionLabelProvider;
43: import org.eclipse.emf.ecore.EcoreFactory;
44: import org.eclipse.emf.ecore.EcorePackage;
45: import org.eclipse.emf.ecore.impl.DynamicEObjectImpl;
46: import org.eclipse.emf.ecore.util.EObjectValidator;
47: import org.eclipse.emf.ecore.util.EcoreUtil;
48: import org.eclipse.emf.emfstore.bowling.BowlingFactory;
49: import org.eclipse.emf.emfstore.bowling.BowlingPackage;
50: import org.eclipse.emf.emfstore.bowling.League;
51: import org.eclipse.emf.emfstore.bowling.Player;
52: import org.eclipse.emf.emfstore.bowling.util.BowlingValidator;
53: import org.eclipse.emfforms.common.spi.validation.exception.ValidationCanceledException;
54: import org.eclipse.emfforms.common.spi.validation.filter.DiagnosticFilter;
55: import org.eclipse.emfforms.common.spi.validation.filter.ObjectFilter;
56: import org.eclipse.emfforms.common.spi.validation.filter.SubTreeFilter;
57: import org.junit.Test;
58: import org.junit.runner.RunWith;
59: import org.mockito.invocation.InvocationOnMock;
60: import org.mockito.runners.MockitoJUnitRunner;
61: import org.mockito.stubbing.Answer;
62:
63: /**
64: * Test cases for the {@link ValidationServiceImpl} class.
65: *
66: * @author Christian W. Damus
67: */
68: @SuppressWarnings("nls")
69: @RunWith(MockitoJUnitRunner.class)
70: public class ValidationServiceImpl_Test {
71: private final ValidationServiceImpl fixture = new ValidationServiceImpl();
72:
73: /**
74: * Initializes me.
75: */
76: public ValidationServiceImpl_Test() {
77: super();
78: }
79:
80: /**
81: * Verify that the service's {@link SubstitutionLabelProvider} is used for
82: * the construction of the "Diagnosis of ..." messages in the diagnostic chains.
83: *
84: * @see <a href="http://eclip.se/526224">bug 526224</a>
85: */
86: @Test
87: public void labelsInDiagnosticChains() {
88: final SubstitutionLabelProvider labels = mock(SubstitutionLabelProvider.class);
89: when(labels.getObjectLabel(any(EObject.class))).thenReturn("The league");
90:
91: final League league = BowlingFactory.eINSTANCE.createLeague();
92: league.setName("Narnian First Division");
93:
94: fixture.setSubstitutionLabelProvider(labels);
95: final Diagnostic diagnostic = fixture.validate(league);
96: assertThat("SubstitutionLabelProvider not used to create diagnostic chain message",
97: diagnostic.getMessage(),
98: containsString("The league"));
99: }
100:
101: /**
102: * Verify that the service can create diagnostic chains even without
103: * a {@link SubstitutionLabelProvider}.
104: *
105: * @see <a href="http://eclip.se/526224">bug 526224</a>
106: */
107: @Test
108: public void diagnosticChainsNoSubstitutionLabelProvider() {
109: final League league = BowlingFactory.eINSTANCE.createLeague();
110: league.setName("Narnian First Division");
111:
112: final Diagnostic diagnostic = fixture.validate(league);
113: assertThat("Invalid diagnostic chain message",
114: diagnostic.getMessage(),
115: // The EcoreUtil::getIdentifier API was used
116: both(containsString("#//")).and(containsString("LeagueImpl")));
117: }
118:
119: /**
120: * Verify that the service uses a single shared validation context map when validating
121: * multiple objects.
122: *
123: * @see <a href="http://eclip.se/526224">bug 526224</a>
124: */
125: @Test
126: public void sharedValidationContext() throws ValidationCanceledException {
127: final Set<Object> validationContexts = Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>());
128:
129: // Fake up a validator that gathers validation context maps
130: final EValidator validator = mock(EValidator.class);
131: when(validator.validate(any(EClass.class), any(EObject.class), any(DiagnosticChain.class),
132: anyMapOf(Object.class, Object.class))).then(new Answer<Boolean>() {
133: @Override
134: public Boolean answer(InvocationOnMock invocation) throws Throwable {
135: validationContexts.add(invocation.getArguments()[3]);
136: return false;
137: }
138: });
139:
140: // Add it to the registry
141: final EValidator oldValidator = EValidator.Registry.INSTANCE.getEValidator(BowlingPackage.eINSTANCE);
142: EValidator.Registry.INSTANCE.put(BowlingPackage.eINSTANCE, validator);
143:
144: try {
145: final League league = BowlingFactory.eINSTANCE.createLeague();
146: league.setName("Narnian First Division");
147:
148: final Player p1 = BowlingFactory.eINSTANCE.createPlayer();
149: p1.setName("Mr Tumnus");
150: league.getPlayers().add(p1);
151: final Player p2 = BowlingFactory.eINSTANCE.createPlayer();
152: p2.setName("Mr Tumnus");
153: league.getPlayers().add(p2);
154:
155: // Validate the entire contents
156: fixture.validate(EcoreUtil.<EObject> getAllContents(Collections.singleton(league)));
157: } finally {
158: // Restore the real validator
159: EValidator.Registry.INSTANCE.put(BowlingPackage.eINSTANCE, oldValidator);
160: }
161:
162: assumeThat("No validation occurred", validationContexts.size(), not(0));
163: assertThat("Too many validation contexts", validationContexts.size(), is(1));
164: }
165:
166: @Test
167: public void diagnosticValidateUsesExistingCustomValidator() {
168:
169: final EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
170: final EClass extendedPlayerClass = EcoreFactory.eINSTANCE.createEClass();
171: extendedPlayerClass.setName("ExtendedPlayer");
172: extendedPlayerClass.getESuperTypes().add(BowlingPackage.eINSTANCE.getPlayer());
173: ePackage.setName("extendedPlayerPackage");
174: ePackage.setNsPrefix("extendedPlayerPackage");
175: ePackage.setNsURI("extendedPlayerPackage");
176: ePackage.getEClassifiers().add(extendedPlayerClass);
177:
178: final EObject extendedPlayer = EcoreUtil.create(extendedPlayerClass);
179: extendedPlayer.eSet(BowlingPackage.eINSTANCE.getPlayer_Height(), 20d);
180:
181: final EValidator validatorForEObject = fixture.getEValidatorForEObject(extendedPlayer);
182: final BasicDiagnostic diagnostic = new BasicDiagnostic();
183: validatorForEObject.validate(extendedPlayerClass, extendedPlayer, diagnostic, null);
184: assertSame(Diagnostic.ERROR, diagnostic.getSeverity());
185: assertSame(2, diagnostic.getChildren().size());
186: assertSame(EObjectValidator.DIAGNOSTIC_SOURCE, diagnostic.getChildren().get(0).getSource());
187: assertSame(BowlingPackage.eINSTANCE.getPlayer_EMails(), diagnostic.getChildren().get(0).getData().get(1));
188: assertSame(BowlingValidator.DIAGNOSTIC_SOURCE, diagnostic.getChildren().get(1).getSource());
189: assertSame(BowlingPackage.eINSTANCE.getPlayer_Height(), diagnostic.getChildren().get(1).getData().get(1));
190: }
191:
192: @Test
193: public void diagnosticValidateUsesDefaultValidatorForDynamicDomainModel() {
194:
195: final EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
196: final EClass extendedPlayerClass = EcoreFactory.eINSTANCE.createEClass();
197: extendedPlayerClass.setName("ExtendedPlayer");
198: extendedPlayerClass.getESuperTypes().add(BowlingPackage.eINSTANCE.getPlayer());
199: ePackage.setName("extendedPlayerPackage");
200: ePackage.setNsPrefix("extendedPlayerPackage");
201: ePackage.setNsURI("extendedPlayerPackage");
202: ePackage.getEClassifiers().add(extendedPlayerClass);
203:
204: final EObject extendedPlayer = new DynamicEObjectImpl(extendedPlayerClass);
205: extendedPlayer.eSet(BowlingPackage.eINSTANCE.getPlayer_Height(), 20d);
206:
207: final EValidator validatorForEObject = fixture.getEValidatorForEObject(extendedPlayer);
208: final BasicDiagnostic diagnostic = new BasicDiagnostic();
209: validatorForEObject.validate(extendedPlayerClass, extendedPlayer, diagnostic, null);
210: assertSame(Diagnostic.ERROR, diagnostic.getSeverity());
211: assertSame(1, diagnostic.getChildren().size());
212: assertSame(EObjectValidator.DIAGNOSTIC_SOURCE, diagnostic.getChildren().get(0).getSource());
213: assertSame(BowlingPackage.eINSTANCE.getPlayer_EMails(), diagnostic.getChildren().get(0).getData().get(1));
214: }
215:
216: @Test
217: public void diagnosticValidateUsesDefaultValidator() {
218:
219: final EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
220: final EClass myClass = EcoreFactory.eINSTANCE.createEClass();
221: myClass.setName("MyClass");
222: final EAttribute nameAttribute = EcoreFactory.eINSTANCE.createEAttribute();
223: nameAttribute.setName("name");
224: nameAttribute.setEType(EcorePackage.eINSTANCE.getEString());
225: nameAttribute.setLowerBound(1);
226: myClass.getEStructuralFeatures().add(nameAttribute);
227: ePackage.setName("standalone");
228: ePackage.setNsPrefix("standalone");
229: ePackage.setNsURI("standalone");
230: ePackage.getEClassifiers().add(myClass);
231:
232: final EObject my = EcoreUtil.create(myClass);
233:
234: final EValidator validatorForEObject = fixture.getEValidatorForEObject(my);
235: final BasicDiagnostic diagnostic = new BasicDiagnostic();
236: validatorForEObject.validate(myClass, my, diagnostic, null);
237: assertSame(Diagnostic.ERROR, diagnostic.getSeverity());
238: assertSame(1, diagnostic.getChildren().size());
239: assertSame(EObjectValidator.DIAGNOSTIC_SOURCE, diagnostic.getChildren().get(0).getSource());
240: assertSame(nameAttribute, diagnostic.getChildren().get(0).getData().get(1));
241: }
242:
243: @Test
244: public void testAddRemoveSubTreeFilter() {
245: final SubTreeFilter subTreeFilterMock = mock(SubTreeFilter.class);
246:
247: fixture.addSubTreeFilter(subTreeFilterMock);
248:
249: assertTrue(fixture.getSubTreeFilters().contains(subTreeFilterMock));
250: assertEquals(1, fixture.getSubTreeFilters().size());
251: assertEquals(0, fixture.getObjectFilters().size());
252: assertEquals(0, fixture.getDiagnosticFilters().size());
253:
254: fixture.removeSubTreeFilter(subTreeFilterMock);
255:
256: assertEquals(0, fixture.getSubTreeFilters().size());
257: assertEquals(0, fixture.getObjectFilters().size());
258: assertEquals(0, fixture.getDiagnosticFilters().size());
259:
260: fixture.addSubTreeFilter(null);
261:
262: assertEquals(0, fixture.getSubTreeFilters().size());
263: assertEquals(0, fixture.getObjectFilters().size());
264: assertEquals(0, fixture.getDiagnosticFilters().size());
265: }
266:
267: @Test
268: public void testAddRemoveObjectFilter() {
269: final ObjectFilter objectFilterMock = mock(ObjectFilter.class);
270:
271: fixture.addObjectFilter(objectFilterMock);
272:
273: assertTrue(fixture.getObjectFilters().contains(objectFilterMock));
274: assertEquals(1, fixture.getObjectFilters().size());
275: assertEquals(0, fixture.getSubTreeFilters().size());
276: assertEquals(0, fixture.getDiagnosticFilters().size());
277:
278: fixture.removeObjectFilter(objectFilterMock);
279:
280: assertEquals(0, fixture.getSubTreeFilters().size());
281: assertEquals(0, fixture.getObjectFilters().size());
282: assertEquals(0, fixture.getDiagnosticFilters().size());
283:
284: fixture.addObjectFilter(null);
285:
286: assertEquals(0, fixture.getSubTreeFilters().size());
287: assertEquals(0, fixture.getObjectFilters().size());
288: assertEquals(0, fixture.getDiagnosticFilters().size());
289: }
290:
291: @Test
292: public void testAddRemoveDiagnosticFilter() {
293: final DiagnosticFilter diagnosticFilterMock = mock(DiagnosticFilter.class);
294:
295: fixture.addDiagnosticFilter(diagnosticFilterMock);
296:
297: assertTrue(fixture.getDiagnosticFilters().contains(diagnosticFilterMock));
298: assertEquals(1, fixture.getDiagnosticFilters().size());
299: assertEquals(0, fixture.getSubTreeFilters().size());
300: assertEquals(0, fixture.getObjectFilters().size());
301:
302: fixture.removeDiagnosticFilter(diagnosticFilterMock);
303:
304: assertEquals(0, fixture.getSubTreeFilters().size());
305: assertEquals(0, fixture.getObjectFilters().size());
306: assertEquals(0, fixture.getDiagnosticFilters().size());
307:
308: fixture.addDiagnosticFilter(null);
309:
310: assertEquals(0, fixture.getSubTreeFilters().size());
311: assertEquals(0, fixture.getObjectFilters().size());
312: assertEquals(0, fixture.getDiagnosticFilters().size());
313: }
314:
315: }
![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
