policy-agent/src/test/java/org/oransc/policyagent/ApplicationTest.java

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2019 Nordix Foundation
   6  * %%
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ========================LICENSE_END===================================
  19  */
  20
  21 package org.oransc.policyagent;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.jupiter.api.Assertions.assertFalse;
  26
  27 import com.google.gson.Gson;
  28 import com.google.gson.GsonBuilder;
  29 import com.google.gson.JsonArray;
  30 import com.google.gson.JsonElement;
  31 import com.google.gson.JsonParser;
  32
  33 import java.util.ArrayList;
  34 import java.util.List;
  35 import java.util.Vector;
  36
  37 import org.junit.jupiter.api.Test;
  38 import org.junit.jupiter.api.extension.ExtendWith;
  39 import org.oransc.policyagent.configuration.ApplicationConfig;
  40 import org.oransc.policyagent.configuration.ImmutableRicConfig;
  41 import org.oransc.policyagent.configuration.RicConfig;
  42 import org.oransc.policyagent.controllers.ImmutableServiceRegistrationInfo;
  43 import org.oransc.policyagent.controllers.ImmutableServiceStatus;
  44 import org.oransc.policyagent.controllers.ServiceRegistrationInfo;
  45 import org.oransc.policyagent.controllers.ServiceStatus;
  46 import org.oransc.policyagent.exceptions.ServiceException;
  47 import org.oransc.policyagent.repository.ImmutablePolicy;
  48 import org.oransc.policyagent.repository.ImmutablePolicyType;
  49 import org.oransc.policyagent.repository.Policies;
  50 import org.oransc.policyagent.repository.Policy;
  51 import org.oransc.policyagent.repository.PolicyType;
  52 import org.oransc.policyagent.repository.PolicyTypes;
  53 import org.oransc.policyagent.repository.Ric;
  54 import org.oransc.policyagent.repository.Rics;
  55 import org.oransc.policyagent.repository.Services;
  56 import org.oransc.policyagent.tasks.RepositorySupervision;
  57 import org.oransc.policyagent.utils.MockA1Client;
  58 import org.oransc.policyagent.utils.MockA1ClientFactory;
  59 import org.springframework.beans.factory.annotation.Autowired;
  60 import org.springframework.boot.test.context.SpringBootTest;
  61 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
  62 import org.springframework.boot.test.context.TestConfiguration;
  63 import org.springframework.boot.web.server.LocalServerPort;
  64 import org.springframework.context.ApplicationContext;
  65 import org.springframework.context.annotation.Bean;
  66 import org.springframework.http.HttpStatus;
  67 import org.springframework.http.ResponseEntity;
  68 import org.springframework.test.context.junit.jupiter.SpringExtension;
  69 import org.springframework.web.client.RestTemplate;
  70
  71 @ExtendWith(SpringExtension.class)
  72 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  73 public class ApplicationTest {
  74     @Autowired
  75     ApplicationContext context;
  76
  77     @Autowired
  78     private Rics rics;
  79
  80     @Autowired
  81     private Policies policies;
  82
  83     @Autowired
  84     private PolicyTypes policyTypes;
  85
  86     @Autowired
  87     MockA1ClientFactory a1ClientFactory;
  88
  89     @Autowired
  90     RepositorySupervision supervision;
  91
  92     @Autowired
  93     Services services;
  94
  95     private static Gson gson = new GsonBuilder() //
  96         .serializeNulls() //
  97         .create(); //
  98
  99     public static class MockApplicationConfig extends ApplicationConfig {
 100         @Override
 101         public String getLocalConfigurationFilePath() {
 102             return ""; // No config file loaded for the test
 103         }
 104     }
 105
 106     /**
 107      * Overrides the BeanFactory.
 108      */
 109     @TestConfiguration
 110     static class TestBeanFactory {
 111         private final PolicyTypes policyTypes = new PolicyTypes();
 112
 113         @Bean
 114         public ApplicationConfig getApplicationConfig() {
 115             return new MockApplicationConfig();
 116         }
 117
 118         @Bean
 119         MockA1ClientFactory getA1ClientFactory() {
 120             return new MockA1ClientFactory(this.policyTypes);
 121         }
 122
 123         @Bean
 124         public Policies getPolicies() {
 125             return new Policies();
 126         }
 127
 128         @Bean
 129         public PolicyTypes getPolicyTypes() {
 130             return this.policyTypes;
 131         }
 132
 133         @Bean
 134         public Rics getRics() {
 135             return new Rics();
 136         }
 137     }
 138
 139     @LocalServerPort
 140     private int port;
 141
 142     private final RestTemplate restTemplate = new RestTemplate();
 143
 144     private void reset() {
 145         rics.clear();
 146         policies.clear();
 147         policyTypes.clear();
 148         assertThat(policies.size()).isEqualTo(0);
 149     }
 150
 151     @Test
 152     public void testGetRics() throws Exception {
 153         reset();
 154         addRic("kista_1");
 155         String url = baseUrl() + "/rics";
 156         String rsp = this.restTemplate.getForObject(url, String.class);
 157         System.out.println(rsp);
 158         assertThat(rsp).contains("kista_1");
 159
 160         url = baseUrl() + "/rics?policyType=ANR";
 161         rsp = this.restTemplate.getForObject(url, String.class);
 162         assertThat(rsp).isEqualTo("[]");
 163     }
 164
 165     @Test
 166     public void testRecovery() throws Exception {
 167         reset();
 168         Policy policy2 = addPolicy("policyId2", "typeName", "service", "ric");
 169
 170         getA1Client("ric").putPolicy(policy2); // put it in the RIC
 171         policies.remove(policy2); // Remove it from the repo -> should be deleted in the RIC
 172
 173         Policy policy = addPolicy("policyId", "typeName", "service", "ric"); // This should be created in the RIC
 174         supervision.checkAllRics(); // The created policy should be put in the RIC
 175         Policies ricPolicies = getA1Client("ric").getPolicies();
 176         assertThat(ricPolicies.size()).isEqualTo(1);
 177         Policy ricPolicy = ricPolicies.get("policyId");
 178         assertThat(ricPolicy.json()).isEqualTo(policy.json());
 179     }
 180
 181     MockA1Client getA1Client(String ricName) throws ServiceException {
 182         return a1ClientFactory.getOrCreateA1Client(ricName);
 183     }
 184
 185     @Test
 186     public void testGetRic() throws Exception {
 187         reset();
 188         Ric ric = addRic("ric1");
 189         ric.addManagedElement("kista_1");
 190         String url = baseUrl() + "/ric?managedElementId=kista_1";
 191
 192         String rsp = this.restTemplate.getForObject(url, String.class);
 193         System.out.println(rsp);
 194
 195         assertThat(rsp).isEqualTo("ric1");
 196     }
 197
 198     @Test
 199     public void testPutPolicy() throws Exception {
 200         putService("service1");
 201
 202         String url = baseUrl() + "/policy?type=type1&instance=instance1&ric=ric1&service=service1";
 203         String json = "{}";
 204         addPolicyType("type1", "ric1");
 205         this.rics.getRic("ric1").setState(Ric.RicState.IDLE);
 206
 207         this.restTemplate.put(url, json);
 208
 209         Policy policy = policies.getPolicy("instance1");
 210
 211         assertThat(policy).isNotNull();
 212         assertThat(policy.id()).isEqualTo("instance1");
 213         assertThat(policy.ownerServiceName()).isEqualTo("service1");
 214
 215         url = baseUrl() + "/policies";
 216         String rsp = this.restTemplate.getForObject(url, String.class);
 217         System.out.println(rsp);
 218     }
 219
 220     private PolicyType addPolicyType(String policyTypeName, String ricName) {
 221         PolicyType type = ImmutablePolicyType.builder() //
 222             .name(policyTypeName) //
 223             .schema("{\"title\":\"" + policyTypeName + "\"}") //
 224             .build();
 225
 226         policyTypes.put(type);
 227         addRic(ricName).addSupportedPolicyType(type);
 228         return type;
 229     }
 230
 231     private Ric addRic(String ricName) {
 232         if (rics.get(ricName) != null) {
 233             return rics.get(ricName);
 234         }
 235         Vector<String> mes = new Vector<>();
 236         RicConfig conf = ImmutableRicConfig.builder() //
 237             .name(ricName) //
 238             .baseUrl(ricName) //
 239             .managedElementIds(mes) //
 240             .build();
 241         Ric ric = new Ric(conf);
 242         this.rics.put(ric);
 243         return ric;
 244     }
 245
 246     private Policy addPolicy(String id, String typeName, String service, String ric) throws ServiceException {
 247         addRic(ric);
 248         Policy p = ImmutablePolicy.builder().id(id) //
 249             .json("{}") //
 250             .ownerServiceName(service) //
 251             .ric(rics.getRic(ric)) //
 252             .type(addPolicyType(typeName, ric)) //
 253             .lastModified("lastModified").build();
 254         policies.put(p);
 255         return p;
 256     }
 257
 258     private Policy addPolicy(String id, String typeName, String service) throws ServiceException {
 259         return addPolicy(id, typeName, service, "ric");
 260     }
 261
 262     private String baseUrl() {
 263         return "http://localhost:" + port;
 264     }
 265
 266     @Test
 267     public void testGetPolicy() throws Exception {
 268         String url = baseUrl() + "/policy?instance=id";
 269         Policy policy = addPolicy("id", "typeName", "service1", "ric1");
 270         {
 271             String rsp = this.restTemplate.getForObject(url, String.class);
 272             assertThat(rsp).isEqualTo(policy.json());
 273         }
 274         {
 275             policies.remove(policy);
 276             ResponseEntity<String> rsp = this.restTemplate.getForEntity(url, String.class);
 277             assertThat(rsp.getStatusCodeValue()).isEqualTo(HttpStatus.NO_CONTENT.value());
 278         }
 279     }
 280
 281     @Test
 282     public void testDeletePolicy() throws Exception {
 283         reset();
 284         String url = baseUrl() + "/policy?instance=id";
 285         Policy policy = addPolicy("id", "typeName", "service1", "ric1");
 286         policy.ric().setState(Ric.RicState.IDLE);
 287         assertThat(policies.size()).isEqualTo(1);
 288
 289         this.restTemplate.delete(url);
 290
 291         assertThat(policies.size()).isEqualTo(0);
 292     }
 293
 294     @Test
 295     public void testGetPolicySchemas() throws Exception {
 296         reset();
 297         addPolicyType("type1", "ric1");
 298         addPolicyType("type2", "ric2");
 299
 300         String url = baseUrl() + "/policy_schemas";
 301         String rsp = this.restTemplate.getForObject(url, String.class);
 302         System.out.println("*** " + rsp);
 303         assertThat(rsp).contains("type1");
 304         assertThat(rsp).contains("type2");
 305         assertThat(rsp).contains("title");
 306
 307         List<String> info = parseSchemas(rsp);
 308         assertEquals(2, info.size());
 309
 310         url = baseUrl() + "/policy_schemas?ric=ric1";
 311         rsp = this.restTemplate.getForObject(url, String.class);
 312         assertThat(rsp).contains("type1");
 313         info = parseSchemas(rsp);
 314         assertEquals(1, info.size());
 315     }
 316
 317     @Test
 318     public void testGetPolicySchema() throws Exception {
 319         reset();
 320         addPolicyType("type1", "ric1");
 321         addPolicyType("type2", "ric2");
 322
 323         String url = baseUrl() + "/policy_schema?id=type1";
 324         String rsp = this.restTemplate.getForObject(url, String.class);
 325         System.out.println(rsp);
 326         assertThat(rsp).contains("type1");
 327         assertThat(rsp).contains("title");
 328     }
 329
 330     @Test
 331     public void testGetPolicyTypes() throws Exception {
 332         reset();
 333         addPolicyType("type1", "ric1");
 334         addPolicyType("type2", "ric2");
 335
 336         String url = baseUrl() + "/policy_types";
 337         String rsp = this.restTemplate.getForObject(url, String.class);
 338         assertThat(rsp).isEqualTo("[\"type2\",\"type1\"]");
 339
 340         url = baseUrl() + "/policy_types?ric=ric1";
 341         rsp = this.restTemplate.getForObject(url, String.class);
 342         assertThat(rsp).isEqualTo("[\"type1\"]");
 343     }
 344
 345     @Test
 346     public void testGetPolicies() throws Exception {
 347         String url = baseUrl() + "/policies";
 348         addPolicy("id1", "type1", "service1");
 349         addPolicy("id2", "type2", "service2");
 350
 351         String rsp = this.restTemplate.getForObject(url, String.class);
 352         System.out.println(rsp);
 353         assertThat(rsp).contains("id1");
 354         assertThat(rsp).contains("id2");
 355     }
 356
 357     @Test
 358     public void testGetPoliciesFilter() throws Exception {
 359         addPolicy("id1", "type1", "service1");
 360         addPolicy("id2", "type1", "service2");
 361         addPolicy("id3", "type2", "service1");
 362
 363         String url = baseUrl() + "/policies?type=type1";
 364         String rsp = this.restTemplate.getForObject(url, String.class);
 365         System.out.println(rsp);
 366         assertThat(rsp).contains("id1");
 367         assertThat(rsp).contains("id2");
 368         assertFalse(rsp.contains("id3"));
 369
 370         url = baseUrl() + "/policies?type=type1&service=service2";
 371         rsp = this.restTemplate.getForObject(url, String.class);
 372         System.out.println(rsp);
 373         assertFalse(rsp.contains("id1"));
 374         assertThat(rsp).contains("id2");
 375         assertFalse(rsp.contains("id3"));
 376     }
 377
 378     private String createServiceJson(String name) {
 379         ServiceRegistrationInfo service = ImmutableServiceRegistrationInfo.builder() //
 380             .keepAliveInterval(1) //
 381             .name(name) //
 382             .callbackUrl("callbackUrl") //
 383             .build();
 384         String json = gson.toJson(service);
 385         return json;
 386     }
 387
 388     private void putService(String name) {
 389         String url = baseUrl() + "/service";
 390         this.restTemplate.put(url, createServiceJson(name));
 391     }
 392
 393     @Test
 394     public void testPutAndGetService() throws Exception {
 395         // PUT
 396         putService("name");
 397
 398         // GET
 399         String url = baseUrl() + "/services?name=name";
 400         String rsp = this.restTemplate.getForObject(url, String.class);
 401         List<ImmutableServiceStatus> info = parseList(rsp, ImmutableServiceStatus.class);
 402         assertThat(info.size() == 1);
 403         ServiceStatus status = info.iterator().next();
 404         assertThat(status.keepAliveInterval() == 1);
 405         assertThat(status.name().equals("name"));
 406
 407         // GET (all)
 408         url = baseUrl() + "/services";
 409         rsp = this.restTemplate.getForObject(url, String.class);
 410         assertThat(rsp.contains("name"));
 411         System.out.println(rsp);
 412
 413         // DELETE
 414         assertThat(services.size() == 1);
 415         url = baseUrl() + "/services?name=name";
 416         this.restTemplate.delete(url);
 417         assertThat(services.size() == 0);
 418     }
 419
 420     private static <T> List<T> parseList(String jsonString, Class<T> clazz) {
 421         List<T> result = new ArrayList<>();
 422         JsonArray jsonArr = JsonParser.parseString(jsonString).getAsJsonArray();
 423         for (JsonElement jsonElement : jsonArr) {
 424             T o = gson.fromJson(jsonElement.toString(), clazz);
 425             result.add(o);
 426         }
 427         return result;
 428     }
 429
 430     private static List<String> parseSchemas(String jsonString) {
 431         JsonArray arrayOfSchema = JsonParser.parseString(jsonString).getAsJsonArray();
 432         List<String> result = new ArrayList<>();
 433         for (JsonElement schemaObject : arrayOfSchema) {
 434             result.add(schemaObject.toString());
 435         }
 436         return result;
 437     }
 438
 439 }