Skip to content

Package: XmiTemplateProvider_Test

XmiTemplateProvider_Test

nameinstructionbranchcomplexitylinemethod
XmiTemplateProvider_Test()
M: 0 C: 3
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
setUp()
M: 0 C: 81
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 21
100%
M: 0 C: 1
100%
testCanProvideTemplates()
M: 0 C: 28
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 6
100%
M: 0 C: 1
100%
testProvideTemplates()
M: 0 C: 116
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 24
100%
M: 0 C: 1
100%
testTemplateLoaders()
M: 0 C: 88
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 19
100%
M: 0 C: 1
100%

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 - bug 546974
14: ******************************************************************************/
15: package org.eclipse.emfforms.internal.core.services.datatemplate;
16:
17: import static org.junit.Assert.assertEquals;
18: import static org.junit.Assert.assertFalse;
19: import static org.junit.Assert.assertTrue;
20: import static org.mockito.Mockito.mock;
21: import static org.mockito.Mockito.spy;
22: import static org.mockito.Mockito.verify;
23: import static org.mockito.Mockito.when;
24:
25: import java.io.IOException;
26: import java.util.Set;
27:
28: import javax.inject.Named;
29:
30: import org.eclipse.core.runtime.IConfigurationElement;
31: import org.eclipse.core.runtime.IContributor;
32: import org.eclipse.core.runtime.IExtensionRegistry;
33: import org.eclipse.emf.common.util.URI;
34: import org.eclipse.emfforms.bazaar.Bid;
35: import org.eclipse.emfforms.bazaar.Create;
36: import org.eclipse.emfforms.core.services.datatemplate.TemplateLoaderService;
37: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.AdminUser;
38: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.AuditFactory;
39: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.AuditPackage;
40: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.GuestUser;
41: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.RegisteredUser;
42: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.User;
43: import org.eclipse.emfforms.core.services.datatemplate.test.model.audit.UserGroup;
44: import org.eclipse.emfforms.datatemplate.DataTemplateFactory;
45: import org.eclipse.emfforms.datatemplate.Template;
46: import org.eclipse.emfforms.spi.common.report.ReportService;
47: import org.junit.Before;
48: import org.junit.Test;
49:
50: /**
51: * JUnit tests for {@link XmiTemplateProvider}.
52: *
53: * @author Lucas Koehler
54: *
55: */
56: public class XmiTemplateProvider_Test {
57:
58:         private XmiTemplateProvider provider;
59:         private Template adminTemplate;
60:         private Template guestTemplate;
61:         private Template registeredTemplate;
62:
63:         @Before
64:         public void setUp() {
65:                 adminTemplate = DataTemplateFactory.eINSTANCE.createTemplate();
66:                 adminTemplate.setName("Admin Template"); //$NON-NLS-1$
67:                 guestTemplate = DataTemplateFactory.eINSTANCE.createTemplate();
68:                 guestTemplate.setName("Guest Template"); //$NON-NLS-1$
69:                 registeredTemplate = DataTemplateFactory.eINSTANCE.createTemplate();
70:                 registeredTemplate.setName("Registered Template"); //$NON-NLS-1$
71:
72:                 final AdminUser adminUser = AuditFactory.eINSTANCE.createAdminUser();
73:                 adminUser.setLogin("admin"); //$NON-NLS-1$
74:                 final GuestUser guestUser = AuditFactory.eINSTANCE.createGuestUser();
75:                 guestUser.setLogin("guest"); //$NON-NLS-1$
76:                 final RegisteredUser registeredUser = AuditFactory.eINSTANCE.createRegisteredUser();
77:                 registeredUser.setLogin("registered"); //$NON-NLS-1$
78:
79:                 adminTemplate.setInstance(adminUser);
80:                 guestTemplate.setInstance(guestUser);
81:                 registeredTemplate.setInstance(registeredUser);
82:
83:                 provider = new XmiTemplateProvider();
84:                 provider.setReportService(mock(ReportService.class));
85:                 provider.registerTemplate(adminTemplate);
86:                 provider.registerTemplate(guestTemplate);
87:                 provider.registerTemplate(registeredTemplate);
88:         }
89:
90:         @Test
91:         public void testCanProvideTemplates() {
92:                 final UserGroup group = AuditFactory.eINSTANCE.createUserGroup();
93:                 assertTrue(provider.canProvideTemplates(group, AuditPackage.Literals.USER_GROUP__ADMINS));
94:                 assertTrue(provider.canProvideTemplates(group, AuditPackage.Literals.USER_GROUP__USERS));
95:                 assertTrue(provider.canProvideTemplates(group, AuditPackage.Literals.USER__DELEGATES));
96:                 assertFalse(provider.canProvideTemplates(group, AuditPackage.Literals.USER__SUB_USERS));
97:         }
98:
99:         @Test
100:         public void testProvideTemplates() {
101:                 final UserGroup group = AuditFactory.eINSTANCE.createUserGroup();
102:                 final User user = AuditFactory.eINSTANCE.createGuestUser();
103:
104:                 // Only the template for admin matches
105:                 final Set<Template> adminSet = provider.provideTemplates(group, AuditPackage.Literals.USER_GROUP__ADMINS);
106:                 assertEquals(1, adminSet.size());
107:                 assertEquals(adminTemplate, adminSet.iterator().next());
108:
109:                 // Only the template for guest matches
110:                 final Set<Template> guestSet = provider.provideTemplates(group, AuditPackage.Literals.USER_GROUP__GUESTS);
111:                 assertEquals(1, guestSet.size());
112:                 assertEquals(guestTemplate, guestSet.iterator().next());
113:
114:                 // The templates for registered and admin (sub class of registered) match
115:                 final Set<Template> registeredSet = provider.provideTemplates(group,
116:                         AuditPackage.Literals.USER_GROUP__REGISTERED_USERS);
117:                 assertEquals(2, registeredSet.size());
118:                 assertTrue(registeredSet.contains(adminTemplate));
119:                 assertTrue(registeredSet.contains(registeredTemplate));
120:
121:                 // The template for admin (sub class of privileged) matches
122:                 final Set<Template> privilegedSet = provider.provideTemplates(group, AuditPackage.Literals.USER_GROUP__ADMINS);
123:                 assertEquals(1, privilegedSet.size());
124:                 assertEquals(adminTemplate, privilegedSet.iterator().next());
125:
126:                 // All templates match (all other user classes are sub classes of User)
127:                 final Set<Template> userSet = provider.provideTemplates(group, AuditPackage.Literals.USER_GROUP__USERS);
128:                 assertEquals(3, userSet.size());
129:                 assertTrue(userSet.contains(adminTemplate));
130:                 assertTrue(userSet.contains(registeredTemplate));
131:                 assertTrue(userSet.contains(guestTemplate));
132:
133:                 // No templates matches for sub-user
134:                 final Set<Template> userGroupSet = provider.provideTemplates(user, AuditPackage.Literals.USER__SUB_USERS);
135:                 assertEquals(0, userGroupSet.size());
136:         }
137:
138:         @SuppressWarnings("nls")
139:         @Test
140:         public void testTemplateLoaders() throws IOException {
141:                 final IExtensionRegistry reg = mock(IExtensionRegistry.class);
142:                 final URI uri = URI.createPlatformPluginURI("datatemplate.test/templates/whatever.xmi", true);
143:                 final String contributorID = "datatemplate.test";
144:                 final IConfigurationElement config = mock(IConfigurationElement.class);
145:                 final IContributor contributor = mock(IContributor.class);
146:                 when(contributor.getName()).thenReturn(contributorID);
147:                 when(config.getContributor()).thenReturn(contributor);
148:                 when(config.getAttribute("file")).thenReturn("/templates/whatever.xmi");
149:                 final IConfigurationElement[] configs = { config };
150:                 when(reg.getConfigurationElementsFor("org.eclipse.emfforms.core.services.datatemplate.xmi"))
151:                         .thenReturn(configs);
152:
153:                 provider.setExtensionRegistry(reg);
154:
155:                 final TemplateLoaderService loader = mock(TemplateLoaderService.class);
156:
157:                 class LoaderProvider implements TemplateLoaderService.Provider {
158:
159:                         @Bid
160:                         public double bid(@Named(CONTRIBUTOR_ID) String contributor, URI uri) {
161:                                 return Double.POSITIVE_INFINITY;
162:                         }
163:
164:                         @Create
165:                         public TemplateLoaderService create() {
166:                                 return loader;
167:                         }
168:                 }
169:                 final LoaderProvider loaderProvider = spy(new LoaderProvider());
170:                 provider.addLoaderServiceProvider(loaderProvider);
171:
172:                 provider.activate();
173:
174:                 verify(loaderProvider).bid(contributorID, uri);
175:                 verify(loader).loadTemplates(uri);
176:         }
177:
178: }