import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.context.TestConfiguration;
+import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.LocalServerPort;
+import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
Duration checkInterval = Duration.ofMillis(1);
return new ServiceSupervision(this.services, this.policies, this.getA1ClientFactory(), checkInterval);
}
+
+ @Bean
+ public ServletWebServerFactory servletContainer() {
+ return new TomcatServletWebServerFactory();
+ }
+
}
@LocalServerPort
ric.getLock().lockBlocking(LockType.EXCLUSIVE);
ric.getLock().unlockBlocking();
assertThat(ric.getLock().getLockCounter()).isEqualTo(0);
- assertThat(ric.getState()).isEqualTo(Ric.RicState.IDLE);
+ assertThat(ric.getState()).isEqualTo(Ric.RicState.AVAILABLE);
}
}
rsp = restClient().get(url).block();
assertThat(rsp).contains("ric2");
assertThat(rsp).doesNotContain("ric1");
+ assertThat(rsp).contains("AVAILABLE");
+
+ // All RICs
+ rsp = restClient().get("/rics").block();
+ assertThat(rsp).contains("ric2");
+ assertThat(rsp).contains("ric1");
// Non existing policy type
url = "/rics?policyType=XXXX";
@Test
public void testSynchronization() throws Exception {
- addRic("ric").setState(Ric.RicState.UNDEFINED);
- String ricName = "ric";
- Policy policy2 = addPolicy("policyId2", "typeName", "service", ricName);
-
- getA1Client(ricName).putPolicy(policy2); // put it in the RIC
+ // Two polictypes will be put in the NearRT RICs
+ PolicyTypes nearRtRicPolicyTypes = new PolicyTypes();
+ nearRtRicPolicyTypes.put(createPolicyType("typeName"));
+ nearRtRicPolicyTypes.put(createPolicyType("typeName2"));
+ this.a1ClientFactory.setPolicyTypes(nearRtRicPolicyTypes);
+
+ // One type and one instance added to the agent storage
+ final String ric1Name = "ric1";
+ Ric ric1 = addRic(ric1Name);
+ Policy policy2 = addPolicy("policyId2", "typeName", "service", ric1Name);
+ Ric ric2 = addRic("ric2");
+
+ getA1Client(ric1Name).putPolicy(policy2); // put it in the RIC
policies.remove(policy2); // Remove it from the repo -> should be deleted in the RIC
String policyId = "policyId";
- Policy policy = addPolicy(policyId, "typeName", "service", ricName); // This should be created in the RIC
+ Policy policy = addPolicy(policyId, "typeName", "service", ric1Name); // This should be created in the RIC
supervision.checkAllRics(); // The created policy should be put in the RIC
- await().untilAsserted(() -> RicState.SYNCHRONIZING.equals(rics.getRic(ricName).getState()));
- await().untilAsserted(() -> RicState.IDLE.equals(rics.getRic(ricName).getState()));
- Policies ricPolicies = getA1Client(ricName).getPolicies();
+ // Wait until synch is completed
+ await().untilAsserted(() -> RicState.SYNCHRONIZING.equals(rics.getRic(ric1Name).getState()));
+ await().untilAsserted(() -> RicState.AVAILABLE.equals(rics.getRic(ric1Name).getState()));
+ await().untilAsserted(() -> RicState.AVAILABLE.equals(rics.getRic("ric2").getState()));
+
+ Policies ricPolicies = getA1Client(ric1Name).getPolicies();
assertThat(ricPolicies.size()).isEqualTo(1);
Policy ricPolicy = ricPolicies.get(policyId);
assertThat(ricPolicy.json()).isEqualTo(policy.json());
+
+ // Both types should be in the agent storage after the synch
+ assertThat(ric1.getSupportedPolicyTypes().size()).isEqualTo(2);
+ assertThat(ric2.getSupportedPolicyTypes().size()).isEqualTo(2);
}
@Test
testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND);
}
- private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId) {
+ private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId,
+ boolean isTransient) {
+ String url;
if (policyTypeName.isEmpty()) {
- return "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
+ url = "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName;
} else {
- return "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ url = "/policy?id=" + policyInstanceId + "&ric=" + ricName + "&service=" + serviceName + "&type="
+ policyTypeName;
}
+ if (isTransient) {
+ url += "&transient=true";
+ }
+ return url;
+ }
+
+ private String putPolicyUrl(String serviceName, String ricName, String policyTypeName, String policyInstanceId) {
+ return putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId, false);
}
@Test
putService(serviceName);
addPolicyType(policyTypeName, ricName);
- String url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
+ // PUT a transient policy
+ String url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId, true);
final String policyBody = jsonString();
- this.rics.getRic(ricName).setState(Ric.RicState.IDLE);
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
restClient().put(url, policyBody).block();
assertThat(policy.id()).isEqualTo(policyInstanceId);
assertThat(policy.ownerServiceName()).isEqualTo(serviceName);
assertThat(policy.ric().name()).isEqualTo("ric1");
+ assertThat(policy.isTransient()).isEqualTo(true);
+
+ // Put a non transient policy
+ url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
+ restClient().put(url, policyBody).block();
+ policy = policies.getPolicy(policyInstanceId);
+ assertThat(policy.isTransient()).isEqualTo(false);
url = "/policies";
String rsp = restClient().get(url).block();
assertThat(rsp.contains(policyInstanceId)).isTrue();
+ url = "/policy?id=" + policyInstanceId;
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(policyBody);
+
// Test of error codes
url = putPolicyUrl(serviceName, ricName + "XX", policyTypeName, policyInstanceId);
testErrorCode(restClient().put(url, policyBody), HttpStatus.NOT_FOUND);
url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
this.rics.getRic(ricName).setState(Ric.RicState.SYNCHRONIZING);
testErrorCode(restClient().put(url, policyBody), HttpStatus.LOCKED);
- this.rics.getRic(ricName).setState(Ric.RicState.IDLE);
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
}
@Test
this.addRic("ric1");
this.addRic("ricXXX");
this.addPolicy("instance1", "type1", "service1", "ric1");
+ this.addPolicy("instance2", "type1", "service1", "ricXXX");
// Try change ric1 -> ricXXX
String urlWrongRic = putPolicyUrl("service1", "ricXXX", "type1", "instance1");
testErrorCode(restClient().put("/service", "crap"), HttpStatus.BAD_REQUEST);
testErrorCode(restClient().put("/service", "{}"), HttpStatus.BAD_REQUEST);
testErrorCode(restClient().put("/service", createServiceJson("name", -123)), HttpStatus.BAD_REQUEST);
+ testErrorCode(restClient().put("/service", createServiceJson("name", 0, "missing.portandprotocol.com")),
+ HttpStatus.BAD_REQUEST);
// GET non existing servive
testErrorCode(restClient().get("/services?name=XXX"), HttpStatus.NOT_FOUND);
private Policy addPolicy(String id, String typeName, String service, String ric) throws ServiceException {
addRic(ric);
- Policy p = ImmutablePolicy.builder().id(id) //
+ Policy p = ImmutablePolicy.builder() //
+ .id(id) //
.json(jsonString()) //
.ownerServiceName(service) //
.ric(rics.getRic(ric)) //
.type(addPolicyType(typeName, ric)) //
- .lastModified("lastModified").build();
+ .lastModified("lastModified") //
+ .isTransient(false) //
+ .build();
policies.put(p);
return p;
}
}
private String createServiceJson(String name, long keepAliveIntervalSeconds) {
- ServiceRegistrationInfo service = new ServiceRegistrationInfo(name, keepAliveIntervalSeconds, "callbackUrl");
+ return createServiceJson(name, keepAliveIntervalSeconds, "https://examples.javacodegeeks.com/core-java/");
+ }
+
+ private String createServiceJson(String name, long keepAliveIntervalSeconds, String url) {
+ ServiceRegistrationInfo service = new ServiceRegistrationInfo(name, keepAliveIntervalSeconds, url);
String json = gson.toJson(service);
return json;
}
private String baseUrl() {
- return "http://localhost:" + port;
+ return "https://localhost:" + port;
}
private String jsonString() {
- return "{\n \"servingCellNrcgi\": \"1\"\n }";
+ return "{\"servingCellNrcgi\":\"1\"}";
}
@Test
addPolicyType("type1", "ric");
addPolicyType("type2", "ric");
- for (int i = 0; i < 100; ++i) {
+ for (int i = 0; i < 10; ++i) {
Thread t =
new Thread(new ConcurrencyTestRunnable(baseUrl(), supervision, a1ClientFactory, rics, policyTypes),
"TestThread_" + i);
return a1ClientFactory.getOrCreateA1Client(ricName);
}
- private PolicyType addPolicyType(String policyTypeName, String ricName) {
- PolicyType type = ImmutablePolicyType.builder() //
+ private PolicyType createPolicyType(String policyTypeName) {
+ return ImmutablePolicyType.builder() //
.name(policyTypeName) //
.schema("{\"title\":\"" + policyTypeName + "\"}") //
.build();
+ }
+ private PolicyType addPolicyType(String policyTypeName, String ricName) {
+ PolicyType type = createPolicyType(policyTypeName);
policyTypes.put(type);
addRic(ricName).addSupportedPolicyType(type);
return type;
.controllerName("") //
.build();
Ric ric = new Ric(conf);
- ric.setState(Ric.RicState.IDLE);
+ ric.setState(Ric.RicState.AVAILABLE);
this.rics.put(ric);
return ric;
}