Move RefreshConfigTask under tasks
[nonrtric.git] / policy-agent / src / test / java / org / oransc / policyagent / tasks / StartupServiceTest.java
index fd98e07..47e7b4d 100644 (file)
 
 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.Mockito.mock;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
-import static org.oransc.policyagent.repository.Ric.RicState.ACTIVE;
+import static org.oransc.policyagent.repository.Ric.RicState.IDLE;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Vector;
 
 import org.junit.jupiter.api.Test;
-import org.oransc.policyagent.clients.RicClient;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.oransc.policyagent.clients.A1Client;
 import org.oransc.policyagent.configuration.ApplicationConfig;
 import org.oransc.policyagent.configuration.ImmutableRicConfig;
 import org.oransc.policyagent.configuration.RicConfig;
-import org.oransc.policyagent.exceptions.ServiceException;
-import org.oransc.policyagent.repository.ImmutablePolicyType;
-import org.oransc.policyagent.repository.PolicyType;
+import org.oransc.policyagent.repository.Policies;
 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.Mono;
 
+@ExtendWith(MockitoExtension.class)
+@RunWith(MockitoJUnitRunner.class)
 public class StartupServiceTest {
     private static final String FIRST_RIC_NAME = "first";
     private static final String FIRST_RIC_URL = "firstUrl";
@@ -54,74 +66,134 @@ public class StartupServiceTest {
 
     private static final String POLICY_TYPE_1_NAME = "type1";
     private static final String POLICY_TYPE_2_NAME = "type2";
+    private static final String POLICY_ID_1 = "policy1";
+    private static final String POLICY_ID_2 = "policy2";
 
+    @Mock
     ApplicationConfig appConfigMock;
 
+    @Mock
+    RefreshConfigTask refreshTaskMock;
+
+    @Mock
+    A1Client a1ClientMock;
+
+    @Test
+    public void startup_allOk() {
+        Mono<Collection<String>> policyTypes1 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
+        Mono<Collection<String>> policyTypes2 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME, POLICY_TYPE_2_NAME));
+        when(a1ClientMock.getPolicyTypeIdentities(anyString())).thenReturn(policyTypes1).thenReturn(policyTypes2);
+        Mono<Collection<String>> policies = Mono.just(Arrays.asList(POLICY_ID_1, POLICY_ID_2));
+        when(a1ClientMock.getPolicyIdentities(anyString())).thenReturn(policies);
+        when(a1ClientMock.getPolicyType(anyString(), anyString())).thenReturn(Mono.just("Schema"));
+        when(a1ClientMock.deletePolicy(anyString(), anyString())).thenReturn(Mono.just("OK"));
+
+        Rics rics = new Rics();
+        PolicyTypes policyTypes = new PolicyTypes();
+        StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, policyTypes,
+            a1ClientMock, new Policies(), new Services());
+
+        serviceUnderTest.startup();
+
+        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);
+
+        await().untilAsserted(() -> assertThat(policyTypes.size()).isEqualTo(2));
+
+        verify(a1ClientMock).getPolicyTypeIdentities(FIRST_RIC_URL);
+        verify(a1ClientMock).deletePolicy(FIRST_RIC_URL, POLICY_ID_1);
+        verify(a1ClientMock).deletePolicy(FIRST_RIC_URL, POLICY_ID_2);
+
+        verify(a1ClientMock).getPolicyTypeIdentities(SECOND_RIC_URL);
+        verify(a1ClientMock).deletePolicy(SECOND_RIC_URL, POLICY_ID_1);
+        verify(a1ClientMock).deletePolicy(SECOND_RIC_URL, POLICY_ID_2);
+
+        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");
+
+        Ric firstRic = rics.get(FIRST_RIC_NAME);
+        assertNotNull(firstRic, "Ric " + FIRST_RIC_NAME + " not added to repository");
+        assertEquals(FIRST_RIC_NAME, firstRic.name(), FIRST_RIC_NAME + " not added to Rics");
+        assertEquals(IDLE, firstRic.state(), "Not correct state for ric " + FIRST_RIC_NAME);
+        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);
+
+        Ric secondRic = rics.get(SECOND_RIC_NAME);
+        assertNotNull(secondRic, "Ric " + SECOND_RIC_NAME + " not added to repository");
+        assertEquals(SECOND_RIC_NAME, secondRic.name(), SECOND_RIC_NAME + " not added to Rics");
+        assertEquals(IDLE, secondRic.state(), "Not correct state for " + SECOND_RIC_NAME);
+        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);
+    }
+
     @Test
-    public void startup_allOk() throws ServiceException {
-        ApplicationConfig appConfigMock = mock(ApplicationConfig.class);
-        Vector<RicConfig> ricConfigs = new Vector<>(2);
-        ricConfigs.add(getRicConfig(FIRST_RIC_NAME, FIRST_RIC_URL, MANAGED_NODE_A));
-        ricConfigs.add(getRicConfig(SECOND_RIC_NAME, SECOND_RIC_URL, MANAGED_NODE_B, MANAGED_NODE_C));
-        when(appConfigMock.getRicConfigs()).thenReturn(ricConfigs);
-
-        Vector<PolicyType> firstTypes = new Vector<>();
-        PolicyType type1 = ImmutablePolicyType.builder().name(POLICY_TYPE_1_NAME).jsonSchema("{}").build();
-        firstTypes.add(type1);
-        Vector<PolicyType> secondTypes = new Vector<>();
-        secondTypes.add(type1);
-        PolicyType type2 = ImmutablePolicyType.builder().name(POLICY_TYPE_2_NAME).jsonSchema("{}").build();
-        secondTypes.add(type2);
-        RicClient ricClientMock = mock(RicClient.class);
-        when(ricClientMock.getPolicyTypes(FIRST_RIC_URL)).thenReturn(firstTypes);
-        when(ricClientMock.getPolicyTypes("secondUrl")).thenReturn(secondTypes);
+    public void startup_unableToConnectToGetTypes() {
+        Mono<?> error = Mono.error(new Exception("Unable to contact ric."));
+        doReturn(error, error).when(a1ClientMock).getPolicyTypeIdentities(anyString());
+        doReturn(error).when(a1ClientMock).getPolicyIdentities(anyString());
 
         Rics rics = new Rics();
         PolicyTypes policyTypes = new PolicyTypes();
-        StartupService serviceUnderTest = new StartupService(appConfigMock, rics, policyTypes, ricClientMock);
+        StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, policyTypes,
+            a1ClientMock, new Policies(), new Services());
 
         serviceUnderTest.startup();
+        serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME, FIRST_RIC_URL, MANAGED_NODE_A),
+            ApplicationConfig.RicConfigUpdate.ADDED);
 
-        verify(ricClientMock).deleteAllPolicies(FIRST_RIC_URL);
-        verify(ricClientMock).getPolicyTypes(FIRST_RIC_URL);
-        verify(ricClientMock).deleteAllPolicies(SECOND_RIC_URL);
-        verify(ricClientMock).getPolicyTypes(SECOND_RIC_URL);
-        verifyNoMoreInteractions(ricClientMock);
-
-        assertEquals(2, policyTypes.size(), "Not correct number of policy types added.");
-        assertEquals(type1, policyTypes.getType(POLICY_TYPE_1_NAME), "Not correct type added.");
-        assertEquals(type2, policyTypes.getType(POLICY_TYPE_2_NAME), "Not correct type added.");
-        assertEquals(2, rics.size(), "Correct nymber of Rics not added to Rics");
-
-        Ric firstRic = rics.getRic(FIRST_RIC_NAME);
-        assertNotNull(firstRic, "Ric \"" + FIRST_RIC_NAME + "\" not added to repositpry");
-        assertEquals(FIRST_RIC_NAME, firstRic.name(), "Not correct Ric \"" + FIRST_RIC_NAME + "\" added to Rics");
-        assertEquals(ACTIVE, firstRic.state(), "Not correct state for \"" + FIRST_RIC_NAME + "\"");
-        assertEquals(1, firstRic.getSupportedPolicyTypes().size(), "Not correct no of types supported");
-        assertTrue(firstRic.isSupportingType(type1), "Not correct type supported");
-        assertEquals(1, firstRic.getManagedNodes().size(), "Not correct no of managed nodes");
-        assertTrue(firstRic.isManaging(MANAGED_NODE_A), "Not managed by node");
-
-        Ric secondRic = rics.getRic(SECOND_RIC_NAME);
-        assertNotNull(secondRic, "Ric \"" + SECOND_RIC_NAME + "\" not added to repositpry");
-        assertEquals(SECOND_RIC_NAME, secondRic.name(), "Not correct Ric \"" + SECOND_RIC_NAME + "\" added to Rics");
-        assertEquals(ACTIVE, secondRic.state(), "Not correct state for \"" + SECOND_RIC_NAME + "\"");
-        assertEquals(2, secondRic.getSupportedPolicyTypes().size(), "Not correct no of types supported");
-        assertTrue(secondRic.isSupportingType(type1), "Not correct type supported");
-        assertTrue(secondRic.isSupportingType(type2), "Not correct type supported");
-        assertEquals(2, secondRic.getManagedNodes().size(), "Not correct no of managed nodes");
-        assertTrue(secondRic.isManaging(MANAGED_NODE_B), "Not correct managed node");
-        assertTrue(secondRic.isManaging(MANAGED_NODE_C), "Not correct managed node");
+        assertEquals(RicState.UNDEFINED, rics.get(FIRST_RIC_NAME).state(), "Not correct state for " + FIRST_RIC_NAME);
     }
 
-    private RicConfig getRicConfig(String name, String baseUrl, String... nodeNames) {
-        Vector<String> managedNodes = new Vector<String>(1);
-        for (String nodeName : nodeNames) {
-            managedNodes.add(nodeName);
+    @Test
+    public void startup_unableToConnectToGetPolicies() {
+
+        Mono<Collection<String>> policyTypes = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
+        when(a1ClientMock.getPolicyTypeIdentities(anyString())).thenReturn(policyTypes);
+        when(a1ClientMock.getPolicyType(anyString(), anyString())).thenReturn(Mono.just("Schema"));
+        Mono<?> error = Mono.error(new Exception("Unable to contact ric."));
+        doReturn(error).when(a1ClientMock).getPolicyIdentities(anyString());
+
+        Rics rics = new Rics();
+        StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, new PolicyTypes(),
+            a1ClientMock, new Policies(), new Services());
+
+        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).state(), "Not correct state for " + FIRST_RIC_NAME);
+    }
+
+    @SafeVarargs
+    private <T> Vector<T> toVector(T... objs) {
+        Vector<T> result = new Vector<>();
+        for (T o : objs) {
+            result.add(o);
         }
+        return result;
+    }
+
+    private RicConfig getRicConfig(String name, String baseUrl, String... managedElementIds) {
         ImmutableRicConfig ricConfig = ImmutableRicConfig.builder() //
             .name(name) //
-            .managedElementIds(managedNodes) //
+            .managedElementIds(toVector(managedElementIds)) //
             .baseUrl(baseUrl) //
             .build();
         return ricConfig;