| /******************************************************************************** |
| * Copyright (c) 2015-2019 Contributors to the Eclipse Foundation |
| * |
| * See the NOTICE file(s) distributed with this work for additional |
| * information regarding copyright ownership. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| ********************************************************************************/ |
| |
| package org.eclipse.mdm.preferences.controller; |
| |
| import static org.assertj.core.api.Assertions.assertThat; |
| import static org.assertj.core.api.Assertions.assertThatThrownBy; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.when; |
| |
| import java.security.Principal; |
| import java.util.List; |
| |
| import javax.ejb.SessionContext; |
| import javax.persistence.EntityManager; |
| import javax.persistence.EntityManagerFactory; |
| import javax.persistence.Persistence; |
| |
| import org.assertj.core.groups.Tuple; |
| import org.eclipse.mdm.preferences.entity.Preference; |
| import org.eclipse.mdm.preferences.entity.PreferenceMessage; |
| import org.eclipse.mdm.preferences.entity.PreferenceMessage.Scope; |
| import org.eclipse.persistence.config.PersistenceUnitProperties; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.mockito.Mockito; |
| |
| import com.google.common.collect.ImmutableMap; |
| |
| public class PreferenceServiceTest { |
| private EntityManagerFactory factory; |
| private EntityManager em; |
| private SessionContext sessionContext = mock(SessionContext.class); |
| private PreferenceService service; |
| |
| @Before |
| public void init() { |
| factory = Persistence.createEntityManagerFactory("preferenceTest", ImmutableMap |
| .of(PersistenceUnitProperties.ECLIPSELINK_PERSISTENCE_XML, "META-INF/persistence-test.xml")); |
| |
| em = factory.createEntityManager(); |
| |
| Principal principal = mock(Principal.class); |
| when(principal.getName()).thenReturn("testUser"); |
| when(sessionContext.getCallerPrincipal()).thenReturn(principal); |
| when(sessionContext.isCallerInRole(Mockito.anyString())).thenReturn(true); |
| service = new PreferenceService(em, sessionContext); |
| } |
| |
| @After |
| public void destroy() { |
| factory.close(); |
| } |
| |
| private void initData(Preference... preferences) { |
| EntityManager emgr = factory.createEntityManager(); |
| emgr.getTransaction().begin(); |
| emgr.createQuery("delete from Preference").executeUpdate(); |
| for (Preference p : preferences) { |
| emgr.persist(p); |
| } |
| |
| emgr.getTransaction().commit(); |
| emgr.close(); |
| } |
| |
| @Test |
| public void testGetPreferences() { |
| initData(new Preference(null, null, "testGetPreferences", "myValue1"), |
| new Preference("MDMTEST", null, "testGetPreferences", "myValue2"), |
| new Preference(null, "testUser", "testGetPreferences", "myValue3"), |
| new Preference(null, "otherUser", "testGetPreferences", "myValue4"), |
| new Preference(null, null, "otherKey", "myValue5")); |
| |
| assertThat(service.getPreferences(null, "testGetPreferences")) |
| .extracting("scope", "source", "user", "key", "value") |
| .containsExactlyInAnyOrder(new Tuple(Scope.SYSTEM, null, null, "testGetPreferences", "myValue1"), |
| new Tuple(Scope.SOURCE, "MDMTEST", null, "testGetPreferences", "myValue2"), |
| new Tuple(Scope.USER, null, "testUser", "testGetPreferences", "myValue3")); |
| } |
| |
| @Test |
| public void testGetPreferencesForSystem() { |
| initData(new Preference(null, null, "testGetPreferencesSystem", "myValue"), |
| new Preference("MDMTEST", null, "testGetPreferencesSystem", "myValue")); |
| |
| assertThat(service.getPreferences("system", "testGetPreferencesSystem")) |
| .extracting("scope", "source", "user", "key", "value") |
| .containsExactly(new Tuple(Scope.SYSTEM, null, null, "testGetPreferencesSystem", "myValue")); |
| } |
| |
| @Test |
| public void testGetPreferencesForSource() { |
| initData(new Preference(null, "testUser", "testGetPreferencesForSource", "myValue"), |
| new Preference("MDM_OTHER", null, "testGetPreferencesForSource", "myValue"), |
| new Preference("MDMTEST", null, "testGetPreferencesForSource", "myValue")); |
| |
| assertThat(service.getPreferences("source", "testGetPreferencesForSource")) |
| .extracting("scope", "source", "user", "key", "value").containsExactlyInAnyOrder( |
| new Tuple(Scope.SOURCE, "MDM_OTHER", null, "testGetPreferencesForSource", "myValue"), |
| new Tuple(Scope.SOURCE, "MDMTEST", null, "testGetPreferencesForSource", "myValue")); |
| } |
| |
| @Test |
| public void testGetPreferencesForUser() { |
| initData(new Preference(null, "other", "testGetPreferencesForUser", "myValue"), |
| new Preference(null, "testUser", "testGetPreferencesForUser", "myValue"), |
| new Preference("MDMTEST", null, "testGetPreferencesForUser", "myValue")); |
| |
| assertThat(service.getPreferences("user", "testGetPreferencesForUser")) |
| .extracting("scope", "source", "user", "key", "value") |
| .containsExactly(new Tuple(Scope.USER, null, "other", "testGetPreferencesForUser", "myValue"), |
| new Tuple(Scope.USER, null, "testUser", "testGetPreferencesForUser", "myValue")); |
| } |
| |
| @Test |
| public void testGetPreferencesBySource() { |
| initData(new Preference("MDMTEST", null, "testGetPreferencesSource", "myValue"), |
| new Preference("MDM_OTHER", null, "testGetPreferencesSource", "myValue")); |
| |
| assertThat(service.getPreferencesBySource("MDMTEST", "testGetPreferencesSource")).hasSize(1) |
| .extracting("scope", "source", "user", "key", "value") |
| .containsExactly(new Tuple(Scope.SOURCE, "MDMTEST", null, "testGetPreferencesSource", "myValue")); |
| } |
| |
| @Test |
| public void testGetPreferencesBySourceKeyEmpty() { |
| initData(new Preference("MDMTEST", null, "testGetPreferencesSourceKeyEmpty", "myValue"), |
| new Preference("MDM_OTHER", null, "testGetPreferencesSourceKeyEmpty", "myValue")); |
| |
| assertThat(service.getPreferencesBySource("MDMTEST", "")).hasSize(1) |
| .extracting("scope", "source", "user", "key", "value").containsExactly( |
| new Tuple(Scope.SOURCE, "MDMTEST", null, "testGetPreferencesSourceKeyEmpty", "myValue")); |
| } |
| |
| @Test |
| public void testAdminCanDeletePreferenceInScopeSystem() { |
| String prefName = "testAdminCanDeletePreference"; |
| initData(new Preference(null, null, prefName, "myValue")); |
| when(sessionContext.isCallerInRole(Mockito.eq("Admin"))).thenReturn(true); |
| |
| List<PreferenceMessage> listBeforeDelete = service.getPreferences("system", prefName); |
| assertThat(listBeforeDelete).hasSize(1); |
| |
| em.getTransaction().begin(); |
| service.deletePreference(listBeforeDelete.get(0).getId()); |
| em.getTransaction().commit(); |
| |
| assertThat(service.getPreferences("system", prefName)).hasSize(0); |
| } |
| |
| @Test |
| public void testOtherRolesCanNotDeletePreferenceInScopeSystem() { |
| String prefName = "testOtherUsersCanNotDeletePreferenceInScopeSystem"; |
| initData(new Preference(null, null, prefName, "myValue")); |
| when(sessionContext.isCallerInRole(Mockito.eq("Admin"))).thenReturn(false); |
| |
| List<PreferenceMessage> listBeforeDelete = service.getPreferences("system", |
| prefName); |
| assertThat(listBeforeDelete).hasSize(1); |
| |
| try { |
| em.getTransaction().begin(); |
| assertThatThrownBy(() -> service.deletePreference(listBeforeDelete.get(0).getId())) |
| .hasMessage("Only users with role Admin are allowed to delete Preference!"); |
| } finally { |
| em.getTransaction().rollback(); |
| } |
| } |
| |
| @Test |
| public void testNonAdminCanDeleteOwnPreferenceInUserScope() { |
| String prefName = "testUserCanDeleteOwnPreferenceInUserScope"; |
| initData(new Preference(null, "testUser", prefName, "myValue")); |
| when(sessionContext.isCallerInRole(Mockito.eq("Admin"))).thenReturn(false); |
| |
| List<PreferenceMessage> listBeforeDelete = service.getPreferences("user", prefName); |
| assertThat(listBeforeDelete).hasSize(1); |
| |
| em.getTransaction().begin(); |
| service.deletePreference(listBeforeDelete.get(0).getId()); |
| em.getTransaction().commit(); |
| |
| assertThat(service.getPreferences("user", prefName)).hasSize(0); |
| } |
| |
| @Test |
| public void testNonAdminCanNotDeleteOtherPreferenceInUserScope() { |
| String prefName = "testNonAdminCanNotDeleteOtherPreferenceInUserScope"; |
| initData(new Preference(null, "otherUser", prefName, "myValue")); |
| when(sessionContext.isCallerInRole(Mockito.eq("Admin"))).thenReturn(true); |
| |
| List<PreferenceMessage> listBeforeDelete = service.getPreferences("user", prefName); |
| assertThat(listBeforeDelete).hasSize(1); |
| when(sessionContext.isCallerInRole(Mockito.eq("Admin"))).thenReturn(false); |
| |
| try { |
| em.getTransaction().begin(); |
| assertThatThrownBy(() -> service.deletePreference(listBeforeDelete.get(0).getId())) |
| .hasMessage("Only users with role Admin are allowed to delete Preference!"); |
| } finally { |
| em.getTransaction().rollback(); |
| } |
| } |
| |
| @Test |
| public void testSaveSystemScope() { |
| PreferenceMessage pref = new PreferenceMessage(); |
| pref.setScope(Scope.SYSTEM); |
| pref.setKey("testSaveSystemScope"); |
| pref.setValue("myValue"); |
| |
| em.getTransaction().begin(); |
| PreferenceMessage saved = service.save(pref); |
| em.getTransaction().commit(); |
| |
| assertThat(saved).hasNoNullFieldsOrPropertiesExcept("source", "user") |
| .hasFieldOrPropertyWithValue("scope", Scope.SYSTEM) |
| .hasFieldOrPropertyWithValue("key", "testSaveSystemScope") |
| .hasFieldOrPropertyWithValue("value", "myValue"); |
| } |
| |
| @Test |
| public void testNonAdminCannotSaveSystemScope() { |
| when(sessionContext.isCallerInRole(Mockito.eq("Admin"))).thenReturn(false); |
| |
| PreferenceMessage pref = new PreferenceMessage(); |
| pref.setScope(Scope.SYSTEM); |
| pref.setKey("testNonAdminCannotSaveSystemScope"); |
| pref.setValue("myValue"); |
| |
| try { |
| em.getTransaction().begin(); |
| assertThatThrownBy(() -> service.save(pref)) |
| .hasMessage( |
| "Only users with role Admin are allowed to save Preferences outside of the USER scope!"); |
| } finally { |
| em.getTransaction().rollback(); |
| } |
| } |
| |
| @Test |
| public void testSaveSourceScope() { |
| PreferenceMessage pref = new PreferenceMessage(); |
| pref.setScope(Scope.SOURCE); |
| pref.setSource("MDMTEST"); |
| pref.setKey("testSaveSourceScope"); |
| pref.setValue("myValue"); |
| |
| em.getTransaction().begin(); |
| PreferenceMessage saved = service.save(pref); |
| em.getTransaction().commit(); |
| |
| assertThat(saved).hasNoNullFieldsOrPropertiesExcept("user").hasFieldOrPropertyWithValue("scope", Scope.SOURCE) |
| .hasFieldOrPropertyWithValue("source", "MDMTEST") |
| .hasFieldOrPropertyWithValue("key", "testSaveSourceScope") |
| .hasFieldOrPropertyWithValue("value", "myValue"); |
| } |
| |
| @Test |
| public void testNonAdminCannotSaveSourceScope() { |
| when(sessionContext.isCallerInRole(Mockito.eq("Admin"))).thenReturn(false); |
| |
| PreferenceMessage pref = new PreferenceMessage(); |
| pref.setScope(Scope.SOURCE); |
| pref.setSource("MDMTEST"); |
| pref.setKey("testNonAdminCannotSaveSystemScope"); |
| pref.setValue("myValue"); |
| |
| try { |
| em.getTransaction().begin(); |
| assertThatThrownBy(() -> service.save(pref)) |
| .hasMessage( |
| "Only users with role Admin are allowed to save Preferences outside of the USER scope!"); |
| } finally { |
| em.getTransaction().rollback(); |
| } |
| } |
| |
| @Test |
| public void testSaveUserScope() { |
| PreferenceMessage pref = new PreferenceMessage(); |
| pref.setScope(Scope.USER); |
| pref.setKey("testSaveUserScope"); |
| pref.setValue("myValue"); |
| |
| em.getTransaction().begin(); |
| PreferenceMessage saved = service.save(pref); |
| em.getTransaction().commit(); |
| |
| assertThat(saved).hasNoNullFieldsOrPropertiesExcept("source").hasFieldOrPropertyWithValue("scope", Scope.USER) |
| .hasFieldOrPropertyWithValue("user", "testUser").hasFieldOrPropertyWithValue("key", "testSaveUserScope") |
| .hasFieldOrPropertyWithValue("value", "myValue"); |
| } |
| |
| @Test |
| public void testSaveOverrideExisting() { |
| initData(new Preference(null, null, "testSaveOverrideExisting", "myValue")); |
| |
| PreferenceMessage pref = new PreferenceMessage(); |
| pref.setScope(Scope.SYSTEM); |
| pref.setKey("testSaveOverrideExisting"); |
| pref.setValue("myValue"); |
| |
| em.getTransaction().begin(); |
| PreferenceMessage saved = service.save(pref); |
| em.getTransaction().commit(); |
| |
| assertThat(saved).hasNoNullFieldsOrPropertiesExcept("source", "user") |
| .hasFieldOrPropertyWithValue("scope", Scope.SYSTEM) |
| .hasFieldOrPropertyWithValue("key", "testSaveOverrideExisting") |
| .hasFieldOrPropertyWithValue("value", "myValue"); |
| |
| assertThat(service.getPreferences("System", "testSaveOverrideExisting")).hasSize(1); |
| } |
| } |