![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: ChangeBroker_ITest$1
ChangeBroker_ITest$1
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| handleNotification(Notification) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2015 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: * jfaltermeier - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.changebroker.provider.test;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertFalse;
18: import static org.junit.Assert.assertNotNull;
19: import static org.junit.Assert.assertTrue;
20: import static org.junit.Assert.fail;
21:
22: import java.util.ArrayList;
23: import java.util.Collection;
24: import java.util.LinkedHashSet;
25: import java.util.List;
26: import java.util.Set;
27:
28: import org.eclipse.emf.common.notify.Notification;
29: import org.eclipse.emf.common.notify.Notifier;
30: import org.eclipse.emf.common.util.EList;
31: import org.eclipse.emf.ecore.EClass;
32: import org.eclipse.emf.ecore.EObject;
33: import org.eclipse.emf.ecore.EcoreFactory;
34: import org.eclipse.emf.ecore.EcorePackage;
35: import org.eclipse.emf.ecp.changebroker.provider.internal.ECPNotificationProvider;
36: import org.eclipse.emf.ecp.changebroker.spi.ChangeBroker;
37: import org.eclipse.emf.ecp.changebroker.spi.ChangeObserver;
38: import org.eclipse.emf.ecp.changebroker.spi.NotificationProvider;
39: import org.eclipse.emf.ecp.core.ECPProject;
40: import org.eclipse.emf.ecp.core.ECPProvider;
41: import org.eclipse.emf.ecp.core.exceptions.ECPProjectWithNameExistsException;
42: import org.eclipse.emf.ecp.core.util.ECPProperties;
43: import org.eclipse.emf.ecp.core.util.ECPUtil;
44: import org.eclipse.emf.ecp.spi.core.DefaultProvider;
45: import org.eclipse.emf.ecp.spi.core.InternalProject;
46: import org.eclipse.emf.ecp.spi.core.ProviderChangeListener;
47: import org.eclipse.emf.ecp.workspace.internal.core.WorkspaceProvider;
48: import org.junit.Before;
49: import org.junit.Test;
50: import org.osgi.framework.BundleContext;
51: import org.osgi.framework.FrameworkUtil;
52: import org.osgi.framework.ServiceReference;
53:
54: /**
55: * Tests the integration with the ChangeBroker service
56: *
57: * @author jfaltermeier
58: *
59: */
60: @SuppressWarnings("restriction")
61: public class ChangeBroker_ITest {
62:
63: /**
64: * @author Jonas
65: *
66: */
67: private final class ProviderChangeListenerMock implements ProviderChangeListener {
68: private final LinkedHashSet<EObject> objectWhichCanBeDeleted;
69:
70: /**
71: * @param objectWhichCanBeDeleted
72: */
73: private ProviderChangeListenerMock(LinkedHashSet<EObject> objectWhichCanBeDeleted) {
74: this.objectWhichCanBeDeleted = objectWhichCanBeDeleted;
75:
76: }
77:
78: @Override
79: public void notify(Notification notification) {
80: fail("no notify expected on delete");
81: }
82:
83: @Override
84: public void postDelete(EObject objectToBeDeleted) {
85: calledMethods = calledMethods + postDelete;
86: }
87:
88: @Override
89: public void preDelete(EObject objectToBeDeleted) {
90: calledMethods = calledMethods + preDelete;
91: }
92:
93: @Override
94: public boolean canDelete(EObject objectToBeDeleted) {
95: calledMethods = calledMethods + canDelete;
96: return objectWhichCanBeDeleted.contains(objectToBeDeleted);
97: }
98: }
99:
100: /**
101: * @author Jonas
102: *
103: */
104: private final class DefaultProviderMock extends DefaultProvider {
105:
106: /**
107: * @param name
108: */
109: private DefaultProviderMock(String name) {
110: super(name);
111: }
112:
113: @Override
114: public boolean isThreadSafe() {
115: // TODO Auto-generated method stub
116: return false;
117: }
118:
119: @Override
120: public Notifier getRoot(InternalProject project) {
121: // TODO Auto-generated method stub
122: return null;
123: }
124:
125: @Override
126: public EList<? extends Object> getElements(InternalProject project) {
127: // TODO Auto-generated method stub
128: return null;
129: }
130:
131: @Override
132: public void cloneProject(InternalProject projectToClone, InternalProject targetProject) {
133: // TODO Auto-generated method stub
134:
135: }
136:
137: private final List<Object> deletedObjects = new ArrayList<Object>();
138:
139: @Override
140: public void doDelete(InternalProject project, Collection<Object> objects) {
141: getDeletedObjects().addAll(objects);
142:
143: }
144:
145: /**
146: * @return the deletedObjects
147: */
148: public List<Object> getDeletedObjects() {
149: return deletedObjects;
150: }
151:
152: }
153:
154: @Test
155: public void testServiceAvailable() {
156: assertTrue(org.eclipse.emf.ecp.changebroker.internal.ChangeBrokerImpl.class.isInstance(broker));
157: final org.eclipse.emf.ecp.changebroker.internal.ChangeBrokerImpl brokerImpl = org.eclipse.emf.ecp.changebroker.internal.ChangeBrokerImpl.class
158: .cast(broker);
159: final Set<NotificationProvider> notificationProviders = brokerImpl.getNotificationProviders();
160: assertEquals(1, notificationProviders.size());
161: assertTrue(ECPNotificationProvider.class.isInstance(notificationProviders.iterator().next()));
162: }
163:
164: @Before
165: public void setUp() {
166: final BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass()).getBundleContext();
167: final ServiceReference<ChangeBroker> serviceReference = bundleContext.getServiceReference(ChangeBroker.class);
168: assertNotNull("Null service reference", serviceReference); //$NON-NLS-1$
169: broker = bundleContext.getService(serviceReference);
170: assertNotNull("ChangeBroker is null", broker); //$NON-NLS-1$
171: }
172:
173: private Notification receivedNotification;
174: private ChangeBroker broker;
175:
176: @Test
177: public void testWorkspaceProviderIntegration() throws ECPProjectWithNameExistsException {
178: final ECPProvider provider = ECPUtil.getECPProviderRegistry().getProvider(WorkspaceProvider.NAME);
179: final ECPProperties properties = ECPUtil.createProperties();
180: properties.addProperty(WorkspaceProvider.PROP_ROOT_URI, WorkspaceProvider.VIRTUAL_ROOT_URI);
181: final ECPProject project = ECPUtil.getECPProjectManager().createProject(provider, "TestProject", properties);
182: final EClass testEObject = EcoreFactory.eINSTANCE.createEClass();
183: project.getContents().add(testEObject);
184: broker.subscribe(new ChangeObserver() {
185:
186: @Override
187: public void handleNotification(Notification notification) {
188: receivedNotification = notification;
189:
190: }
191: });
192: final String testName = "testName";
193: testEObject.setName(testName);
194: assertNotNull(receivedNotification);
195: assertEquals(testEObject, receivedNotification.getNotifier());
196: assertEquals(EcorePackage.eINSTANCE.getENamedElement_Name(), receivedNotification.getFeature());
197: assertEquals(testName, receivedNotification.getNewValue());
198: }
199:
200: private String calledMethods = "";
201: private final String postDelete = "postDelete";
202: private final String preDelete = "preDelete";
203: private final String canDelete = "canDelete";
204:
205: @Test
206: public void testDeleteNotificationCanDelete() {
207: final DefaultProviderMock providerMock = new DefaultProviderMock("testProvider");
208: final EClass toBeDeletedEObject = EcoreFactory.eINSTANCE.createEClass();
209: final LinkedHashSet<EObject> objectWhichCanBeDeleted = new LinkedHashSet<EObject>();
210: objectWhichCanBeDeleted.add(toBeDeletedEObject);
211: providerMock
212: .registerChangeListener(new ProviderChangeListenerMock(objectWhichCanBeDeleted));
213: final Set<Object> toBeDeleted = new LinkedHashSet<Object>();
214: toBeDeleted.add(toBeDeletedEObject);
215: final InternalProject project = null;
216: providerMock.delete(project, toBeDeleted);
217: assertEquals(canDelete + preDelete + postDelete, calledMethods);
218: assertEquals(1, providerMock.getDeletedObjects().size());
219: assertTrue(providerMock.getDeletedObjects().contains(toBeDeletedEObject));
220: }
221:
222: @Test
223: public void testDeleteNotificationCannotDelete() {
224: final DefaultProviderMock providerMock = new DefaultProviderMock("testProvider");
225: final EClass toBeDeletedEObject = EcoreFactory.eINSTANCE.createEClass();
226: final LinkedHashSet<EObject> objectWhichCanBeDeleted = new LinkedHashSet<EObject>();
227: providerMock
228: .registerChangeListener(new ProviderChangeListenerMock(objectWhichCanBeDeleted));
229: final Set<Object> toBeDeleted = new LinkedHashSet<Object>();
230: toBeDeleted.add(toBeDeletedEObject);
231: final InternalProject project = null;
232: providerMock.delete(project, toBeDeleted);
233: assertEquals(canDelete, calledMethods);
234: assertEquals(0, providerMock.getDeletedObjects().size());
235: assertFalse(providerMock.getDeletedObjects().contains(toBeDeletedEObject));
236: }
237:
238: @Test
239: public void testDeleteNotificationCanAndCannotDelete() {
240: final DefaultProviderMock providerMock = new DefaultProviderMock("testProvider");
241: final EClass toBeDeletedEObject1 = EcoreFactory.eINSTANCE.createEClass();
242: final EClass toBeDeletedEObject2 = EcoreFactory.eINSTANCE.createEClass();
243: final LinkedHashSet<EObject> objectWhichCanBeDeleted = new LinkedHashSet<EObject>();
244: objectWhichCanBeDeleted.add(toBeDeletedEObject1);
245: providerMock
246: .registerChangeListener(new ProviderChangeListenerMock(objectWhichCanBeDeleted));
247: final Set<Object> toBeDeleted = new LinkedHashSet<Object>();
248: toBeDeleted.add(toBeDeletedEObject1);
249: toBeDeleted.add(toBeDeletedEObject2);
250: final InternalProject project = null;
251: providerMock.delete(project, toBeDeleted);
252: assertEquals(canDelete + preDelete + canDelete + postDelete, calledMethods);
253: assertEquals(1, providerMock.getDeletedObjects().size());
254: assertTrue(providerMock.getDeletedObjects().contains(toBeDeletedEObject1));
255: }
256:
257: @Test
258: public void testDeleteNotificationEObjectAndObject() {
259: final DefaultProviderMock providerMock = new DefaultProviderMock("testProvider");
260: final EClass toBeDeletedEObject1 = EcoreFactory.eINSTANCE.createEClass();
261: final LinkedHashSet<EObject> objectWhichCanBeDeleted = new LinkedHashSet<EObject>();
262: providerMock
263: .registerChangeListener(new ProviderChangeListenerMock(objectWhichCanBeDeleted));
264: final Set<Object> toBeDeleted = new LinkedHashSet<Object>();
265: toBeDeleted.add(toBeDeletedEObject1);
266: final Object otherObjectToBeDeleted = "";
267: toBeDeleted.add(otherObjectToBeDeleted);
268: final InternalProject project = null;
269: providerMock.delete(project, toBeDeleted);
270: assertEquals(canDelete, calledMethods);
271: assertEquals(1, providerMock.getDeletedObjects().size());
272: assertTrue(providerMock.getDeletedObjects().contains(otherObjectToBeDeleted));
273: }
274:
275: }