From: elinuxhenrik Date: Wed, 4 Mar 2020 14:04:32 +0000 (+0100) Subject: Add tests for StartupService X-Git-Tag: 2.0.0~142 X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=refs%2Fchanges%2F71%2F2671%2F3;p=nonrtric.git Add tests for StartupService Change-Id: I686d0acb2a0ca976923c6cfeed1502ebae52cb80 Issue-ID: NONRTRIC-140 Signed-off-by: elinuxhenrik --- diff --git a/policy-agent/src/main/java/org/oransc/policyagent/tasks/StartupService.java b/policy-agent/src/main/java/org/oransc/policyagent/tasks/StartupService.java index d3b8b351..7068da4e 100644 --- a/policy-agent/src/main/java/org/oransc/policyagent/tasks/StartupService.java +++ b/policy-agent/src/main/java/org/oransc/policyagent/tasks/StartupService.java @@ -22,6 +22,7 @@ package org.oransc.policyagent.tasks; import org.oransc.policyagent.clients.A1ClientFactory; import org.oransc.policyagent.configuration.ApplicationConfig; +import org.oransc.policyagent.configuration.ApplicationConfig.RicConfigUpdate; import org.oransc.policyagent.configuration.RicConfig; import org.oransc.policyagent.repository.Policies; import org.oransc.policyagent.repository.PolicyTypes; @@ -78,19 +79,23 @@ public class StartupService implements ApplicationConfig.Observer { } @Override - public void onRicConfigUpdate(RicConfig ricConfig, ApplicationConfig.RicConfigUpdate event) { + public void onRicConfigUpdate(RicConfig ricConfig, RicConfigUpdate event) { synchronized (this.rics) { - if (event.equals(ApplicationConfig.RicConfigUpdate.ADDED) - || event.equals(ApplicationConfig.RicConfigUpdate.CHANGED)) { - Ric ric = new Ric(ricConfig); - rics.put(ric); - RicSynchronizationTask synchronizationTask = - new RicSynchronizationTask(a1ClientFactory, policyTypes, policies, services); - synchronizationTask.run(ric); - } else if (event.equals(ApplicationConfig.RicConfigUpdate.REMOVED)) { - rics.remove(ricConfig.name()); - } else { - logger.debug("Unhandled event: {}", event); + switch (event) { + case ADDED: + case CHANGED: + Ric ric = new Ric(ricConfig); + rics.put(ric); + RicSynchronizationTask synchronizationTask = createSynchronizationTask(); + synchronizationTask.run(ric); + break; + + case REMOVED: + rics.remove(ricConfig.name()); + break; + + default: + logger.error("Unhandled ric event: {}", event); } } } @@ -104,4 +109,7 @@ public class StartupService implements ApplicationConfig.Observer { refreshConfigTask.start(); } + RicSynchronizationTask createSynchronizationTask() { + return new RicSynchronizationTask(a1ClientFactory, policyTypes, policies, services); + } } diff --git a/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java b/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java index eeecc1c9..5590c5e3 100644 --- a/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java +++ b/policy-agent/src/test/java/org/oransc/policyagent/tasks/StartupServiceTest.java @@ -20,194 +20,118 @@ package org.oransc.policyagent.tasks; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; -import static org.oransc.policyagent.repository.Ric.RicState.IDLE; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; -import com.google.common.collect.ImmutableList; - -import java.util.Arrays; import java.util.Collections; import java.util.List; -import java.util.Vector; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import org.oransc.policyagent.clients.A1Client; -import org.oransc.policyagent.clients.A1ClientFactory; import org.oransc.policyagent.configuration.ApplicationConfig; import org.oransc.policyagent.configuration.ImmutableRicConfig; import org.oransc.policyagent.configuration.RicConfig; -import org.oransc.policyagent.repository.Policies; -import org.oransc.policyagent.repository.Policy; -import org.oransc.policyagent.repository.PolicyType; -import org.oransc.policyagent.repository.PolicyTypes; import org.oransc.policyagent.repository.Ric; -import org.oransc.policyagent.repository.Ric.RicState; import org.oransc.policyagent.repository.Rics; -import org.oransc.policyagent.repository.Services; - -import reactor.core.publisher.Flux; -import reactor.core.publisher.Mono; @ExtendWith(MockitoExtension.class) public class StartupServiceTest { private static final String FIRST_RIC_NAME = "first"; - private static final String FIRST_RIC_URL = "firstUrl"; private static final String SECOND_RIC_NAME = "second"; - private static final String SECOND_RIC_URL = "secondUrl"; - private static final String MANAGED_NODE_A = "nodeA"; - private static final String MANAGED_NODE_B = "nodeB"; - private static final String MANAGED_NODE_C = "nodeC"; - - private static final String POLICY_TYPE_1_NAME = "type1"; - private static final String POLICY_TYPE_2_NAME = "type2"; + @Mock ApplicationConfig appConfigMock; + @Mock RefreshConfigTask refreshTaskMock; + @Mock + RicSynchronizationTask synchronizationTaskMock; - A1Client a1ClientMock; - A1ClientFactory a1ClientFactory; + @Test + public void startup_thenServiceIsAddedAsObeserverAndRefreshIsStarted() { + StartupService serviceUnderTest = + new StartupService(appConfigMock, refreshTaskMock, null, null, null, null, null); - @BeforeEach - public void init() throws Exception { - a1ClientMock = mock(A1Client.class); - a1ClientFactory = mock(A1ClientFactory.class); - appConfigMock = mock(ApplicationConfig.class); - refreshTaskMock = mock(RefreshConfigTask.class); - doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any()); + serviceUnderTest.startup(); + + verify(appConfigMock).addObserver(serviceUnderTest); + verify(refreshTaskMock).start(); } @Test - public void startupAndAllOk_thenRicsAreConfiguredInRepository() { - Mono> policyTypes1 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)); - Mono> policyTypes2 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME, POLICY_TYPE_2_NAME)); - doReturn(policyTypes1, policyTypes2).when(a1ClientMock).getPolicyTypeIdentities(); - doReturn(Mono.just("Schema")).when(a1ClientMock).getPolicyTypeSchema(anyString()); - doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies(); + public void twoNewRicsAddedToConfiguration_thenSynchronizationIsStartedAndTwoRicsAreAddedInRepository() { Rics rics = new Rics(); - PolicyTypes policyTypes = new PolicyTypes(); - StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, policyTypes, - a1ClientFactory, new Policies(), new Services()); + StartupService serviceUnderTest = + spy(new StartupService(appConfigMock, refreshTaskMock, rics, null, null, null, null)); - serviceUnderTest.startup(); + doReturn(synchronizationTaskMock).when(serviceUnderTest).createSynchronizationTask(); - serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME, FIRST_RIC_URL, MANAGED_NODE_A), - ApplicationConfig.RicConfigUpdate.ADDED); - serviceUnderTest.onRicConfigUpdate( - getRicConfig(SECOND_RIC_NAME, SECOND_RIC_URL, MANAGED_NODE_B, MANAGED_NODE_C), - ApplicationConfig.RicConfigUpdate.ADDED); + serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME), ApplicationConfig.RicConfigUpdate.ADDED); + serviceUnderTest.onRicConfigUpdate(getRicConfig(SECOND_RIC_NAME), ApplicationConfig.RicConfigUpdate.ADDED); Ric firstRic = rics.get(FIRST_RIC_NAME); - Ric secondRic = rics.get(SECOND_RIC_NAME); - await().untilAsserted(() -> assertThat(firstRic.getState()).isEqualTo(IDLE)); - await().untilAsserted(() -> assertThat(secondRic.getState()).isEqualTo(IDLE)); - - assertTrue(policyTypes.contains(POLICY_TYPE_1_NAME), POLICY_TYPE_1_NAME + " not added to PolicyTypes."); - assertTrue(policyTypes.contains(POLICY_TYPE_2_NAME), POLICY_TYPE_2_NAME + " not added to PolicyTypes."); - assertEquals(2, rics.size(), "Correct number of Rics not added to Rics"); - - assertNotNull(firstRic, "Ric " + FIRST_RIC_NAME + " not added to repository"); assertEquals(FIRST_RIC_NAME, firstRic.name(), FIRST_RIC_NAME + " not added to Rics"); + verify(synchronizationTaskMock, times(1)).run(firstRic); - assertEquals(1, firstRic.getSupportedPolicyTypes().size(), - "Not correct no of types supported for ric " + FIRST_RIC_NAME); - assertTrue(firstRic.isSupportingType(POLICY_TYPE_1_NAME), - POLICY_TYPE_1_NAME + " not supported by ric " + FIRST_RIC_NAME); - assertEquals(1, firstRic.getManagedElementIds().size(), - "Not correct no of managed nodes for ric " + FIRST_RIC_NAME); - assertTrue(firstRic.isManaging(MANAGED_NODE_A), MANAGED_NODE_A + " not managed by ric " + FIRST_RIC_NAME); - - assertNotNull(secondRic, "Ric " + SECOND_RIC_NAME + " not added to repository"); + Ric secondRic = rics.get(SECOND_RIC_NAME); assertEquals(SECOND_RIC_NAME, secondRic.name(), SECOND_RIC_NAME + " not added to Rics"); - assertEquals(2, secondRic.getSupportedPolicyTypes().size(), - "Not correct no of types supported for ric " + SECOND_RIC_NAME); - assertTrue(secondRic.isSupportingType(POLICY_TYPE_1_NAME), - POLICY_TYPE_1_NAME + " not supported by ric " + SECOND_RIC_NAME); - assertTrue(secondRic.isSupportingType(POLICY_TYPE_2_NAME), - POLICY_TYPE_2_NAME + " not supported by ric " + SECOND_RIC_NAME); - assertEquals(2, secondRic.getManagedElementIds().size(), - "Not correct no of managed nodes for ric " + SECOND_RIC_NAME); - assertTrue(secondRic.isManaging(MANAGED_NODE_B), MANAGED_NODE_B + " not managed by ric " + SECOND_RIC_NAME); - assertTrue(secondRic.isManaging(MANAGED_NODE_C), MANAGED_NODE_C + " not managed by ric " + SECOND_RIC_NAME); + verify(synchronizationTaskMock).run(secondRic); } @Test - public void startupAndUnableToConnectToGetTypes_thenRicStateSetToUndefined() { - Mono error = Mono.error(new Exception("Unable to contact ric.")); - doReturn(error, error).when(a1ClientMock).getPolicyTypeIdentities(); - + public void oneRicIsChanged_thenSynchronizationIsStartedAndRicIsUpdatedInRepository() { Rics rics = new Rics(); - PolicyTypes policyTypes = new PolicyTypes(); - StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, policyTypes, - a1ClientFactory, new Policies(), new Services()); + Ric originalRic = new Ric(getRicConfig(FIRST_RIC_NAME, "managedElement1")); + rics.put(originalRic); - serviceUnderTest.startup(); - serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME, FIRST_RIC_URL, MANAGED_NODE_A), - ApplicationConfig.RicConfigUpdate.ADDED); - - assertEquals(RicState.UNDEFINED, rics.get(FIRST_RIC_NAME).getState(), - "Not correct state for " + FIRST_RIC_NAME); - } + StartupService serviceUnderTest = + spy(new StartupService(appConfigMock, refreshTaskMock, rics, null, null, null, null)); - @Test - public void startupAndUnableToConnectToDeleteAllPolicies_thenRicStateSetToUndefined() { + doReturn(synchronizationTaskMock).when(serviceUnderTest).createSynchronizationTask(); - Mono> policyTypes = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)); - when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(policyTypes); - when(a1ClientMock.getPolicyTypeSchema(anyString())).thenReturn(Mono.just("Schema")); - Flux error = Flux.error(new Exception("Unable to contact ric.")); - doReturn(error).when(a1ClientMock).deleteAllPolicies(); + String updatedManagedElementName = "managedElement2"; + serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME, updatedManagedElementName), + ApplicationConfig.RicConfigUpdate.CHANGED); - RicConfig ricConfig = mock(RicConfig.class); - when(ricConfig.name()).thenReturn(FIRST_RIC_NAME); - when(ricConfig.managedElementIds()).thenReturn(ImmutableList.copyOf(Collections.emptyList())); - Ric ric = new Ric(ricConfig); - - PolicyType policyType = mock(PolicyType.class); - when(policyType.name()).thenReturn(POLICY_TYPE_1_NAME); + Ric firstRic = rics.get(FIRST_RIC_NAME); + assertEquals(FIRST_RIC_NAME, firstRic.name(), FIRST_RIC_NAME + " not added to Rics"); + assertTrue(firstRic.getManagedElementIds().contains(updatedManagedElementName), "Ric not updated"); + verify(synchronizationTaskMock).run(firstRic); + } - Policy policy = mock(Policy.class); - when(policy.ric()).thenReturn(ric); - when(policy.type()).thenReturn(policyType); - Policies policies = new Policies(); - policies.put(policy); + @Test + public void oneRicIsRemoved_thenNoSynchronizationIsStartedAndRicIsDeletedFromRepository() { + Rics rics = new Rics(); + RicConfig ricConfig = getRicConfig(FIRST_RIC_NAME); + rics.put(new Ric(ricConfig)); - StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, new Rics(), - new PolicyTypes(), a1ClientFactory, policies, new Services()); + StartupService serviceUnderTest = + new StartupService(appConfigMock, refreshTaskMock, rics, null, null, null, null); - serviceUnderTest.startup(); - serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME, FIRST_RIC_URL, MANAGED_NODE_A), - ApplicationConfig.RicConfigUpdate.ADDED); + serviceUnderTest.onRicConfigUpdate(ricConfig, ApplicationConfig.RicConfigUpdate.REMOVED); - assertEquals(RicState.UNDEFINED, ric.getState(), "Not correct state for " + FIRST_RIC_NAME); + assertEquals(0, rics.size(), "Ric not deleted"); } - @SafeVarargs - private Vector toVector(T... objs) { - Vector result = new Vector<>(); - for (T o : objs) { - result.add(o); - } - return result; + private RicConfig getRicConfig(String name) { + return getRicConfig(name, null); } - private RicConfig getRicConfig(String name, String baseUrl, String... managedElementIds) { + private RicConfig getRicConfig(String name, String managedElementName) { + List managedElements = Collections.emptyList(); + if (managedElementName != null) { + managedElements = Collections.singletonList(managedElementName); + } ImmutableRicConfig ricConfig = ImmutableRicConfig.builder() // .name(name) // - .managedElementIds(toVector(managedElementIds)) // - .baseUrl(baseUrl) // + .managedElementIds(managedElements) // + .baseUrl("baseUrl") // .build(); return ricConfig; }