/*-
* ========================LICENSE_START=================================
- * ONAP : ccsdk oran
- * ======================================================================
- * Copyright (C) 2019-2020 Nordix Foundation. All rights reserved.
- * ======================================================================
+ * O-RAN-SC
+ * %%
+ * Copyright (C) 2020 Nordix Foundation
+ * %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParser;
-import java.util.ArrayList;
-import java.util.Collection;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+import java.lang.invoke.MethodHandles;
+import java.util.Arrays;
+import org.json.JSONObject;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.oransc.enrichment.clients.AsyncRestClient;
-import org.oransc.enrichment.clients.ProducerJobInfo;
+import org.oransc.enrichment.clients.AsyncRestClientFactory;
import org.oransc.enrichment.configuration.ApplicationConfig;
+import org.oransc.enrichment.configuration.ImmutableHttpProxyConfig;
import org.oransc.enrichment.configuration.ImmutableWebClientConfig;
import org.oransc.enrichment.configuration.WebClientConfig;
+import org.oransc.enrichment.configuration.WebClientConfig.HttpProxyConfig;
+import org.oransc.enrichment.controller.ConsumerSimulatorController;
import org.oransc.enrichment.controller.ProducerSimulatorController;
-import org.oransc.enrichment.controllers.consumer.ConsumerConsts;
-import org.oransc.enrichment.controllers.consumer.ConsumerEiJobInfo;
-import org.oransc.enrichment.controllers.producer.ProducerConsts;
-import org.oransc.enrichment.controllers.producer.ProducerRegistrationInfo;
-import org.oransc.enrichment.controllers.producer.ProducerRegistrationInfo.ProducerEiTypeRegistrationInfo;
+import org.oransc.enrichment.controllers.a1e.A1eConsts;
+import org.oransc.enrichment.controllers.a1e.A1eEiJobInfo;
+import org.oransc.enrichment.controllers.a1e.A1eEiJobStatus;
+import org.oransc.enrichment.controllers.a1e.A1eEiTypeInfo;
+import org.oransc.enrichment.controllers.r1consumer.ConsumerConsts;
+import org.oransc.enrichment.controllers.r1consumer.ConsumerInfoTypeInfo;
+import org.oransc.enrichment.controllers.r1consumer.ConsumerJobInfo;
+import org.oransc.enrichment.controllers.r1consumer.ConsumerJobStatus;
+import org.oransc.enrichment.controllers.r1consumer.ConsumerTypeRegistrationInfo;
+import org.oransc.enrichment.controllers.r1consumer.ConsumerTypeSubscriptionInfo;
+import org.oransc.enrichment.controllers.r1producer.ProducerCallbacks;
+import org.oransc.enrichment.controllers.r1producer.ProducerConsts;
+import org.oransc.enrichment.controllers.r1producer.ProducerInfoTypeInfo;
+import org.oransc.enrichment.controllers.r1producer.ProducerJobInfo;
+import org.oransc.enrichment.controllers.r1producer.ProducerRegistrationInfo;
+import org.oransc.enrichment.controllers.r1producer.ProducerStatusInfo;
import org.oransc.enrichment.exceptions.ServiceException;
-import org.oransc.enrichment.repository.EiJob;
-import org.oransc.enrichment.repository.EiJobs;
-import org.oransc.enrichment.repository.EiProducers;
-import org.oransc.enrichment.repository.EiType;
-import org.oransc.enrichment.repository.EiTypes;
+import org.oransc.enrichment.repository.InfoJob;
+import org.oransc.enrichment.repository.InfoJobs;
+import org.oransc.enrichment.repository.InfoProducer;
+import org.oransc.enrichment.repository.InfoProducers;
+import org.oransc.enrichment.repository.InfoType;
+import org.oransc.enrichment.repository.InfoTypeSubscriptions;
+import org.oransc.enrichment.repository.InfoTypes;
+import org.oransc.enrichment.tasks.ProducerSupervision;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
@TestPropertySource(
properties = { //
"server.ssl.key-store=./config/keystore.jks", //
- "app.webclient.trust-store=./config/truststore.jks"})
+ "app.webclient.trust-store=./config/truststore.jks", //
+ "app.vardata-directory=./target"})
class ApplicationTest {
- private final String EI_TYPE_ID = "typeId";
- private final String EI_PRODUCER_ID = "producerId";
+ private final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+ private final String TYPE_ID = "typeId";
+ private final String PRODUCER_ID = "producerId";
private final String EI_JOB_PROPERTY = "\"property1\"";
+ private final String EI_JOB_ID = "jobId";
@Autowired
ApplicationContext context;
@Autowired
- EiJobs eiJobs;
+ InfoJobs infoJobs;
@Autowired
- EiTypes eiTypes;
+ InfoTypes infoTypes;
@Autowired
- EiProducers eiProducers;
+ InfoProducers infoProducers;
@Autowired
ApplicationConfig applicationConfig;
@Autowired
ProducerSimulatorController producerSimulator;
- private static Gson gson = new GsonBuilder() //
- .serializeNulls() //
- .create(); //
+ @Autowired
+ ConsumerSimulatorController consumerSimulator;
+
+ @Autowired
+ ProducerSupervision producerSupervision;
+
+ @Autowired
+ ProducerCallbacks producerCallbacks;
+
+ @Autowired
+ InfoTypeSubscriptions infoTypeSubscriptions;
+
+ private static Gson gson = new GsonBuilder().create();
/**
* Overrides the BeanFactory.
@BeforeEach
void reset() {
- this.eiJobs.clear();
- this.eiTypes.clear();
- this.eiProducers.clear();
+ this.infoJobs.clear();
+ this.infoTypes.clear();
+ this.infoProducers.clear();
this.producerSimulator.getTestResults().reset();
+ this.consumerSimulator.getTestResults().reset();
}
@AfterEach
}
@Test
- void testGetEiTypes() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, "test");
- String url = ConsumerConsts.API_ROOT + "/eitypes";
+ void generateApiDoc() throws FileNotFoundException {
+ String url = "/v3/api-docs";
+ ResponseEntity<String> resp = restClient().getForEntity(url).block();
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
+
+ JSONObject jsonObj = new JSONObject(resp.getBody());
+ assertThat(jsonObj.remove("servers")).isNotNull();
+
+ String indented = jsonObj.toString(4);
+ try (PrintStream out = new PrintStream(new FileOutputStream("api/ecs-api.json"))) {
+ out.print(indented);
+ }
+ }
+
+ @Test
+ void a1eGetEiTypes() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, "test");
+ String url = A1eConsts.API_ROOT + "/eitypes";
String rsp = restClient().get(url).block();
assertThat(rsp).isEqualTo("[\"test\"]");
}
@Test
- void testGetEiType() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, "test");
- String url = ConsumerConsts.API_ROOT + "/eitypes/test";
+ void consumerGetInfoTypes() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, "test");
+ String url = ConsumerConsts.API_ROOT + "/info-types";
String rsp = restClient().get(url).block();
- assertThat(rsp).contains("job_data_schema");
+ assertThat(rsp).isEqualTo("[\"test\"]");
}
@Test
- void testGetEiTypeNotFound() throws Exception {
- String url = ConsumerConsts.API_ROOT + "/eitypes/junk";
- testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find EI type: junk");
+ void a1eGetEiTypesEmpty() throws Exception {
+ String url = A1eConsts.API_ROOT + "/eitypes";
+ String rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo("[]");
}
@Test
- void testGetEiJobsIds() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- putEiJob(EI_TYPE_ID, "jobId");
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs";
+ void consumerGetEiTypesEmpty() throws Exception {
+ String url = ConsumerConsts.API_ROOT + "/info-types";
String rsp = restClient().get(url).block();
- assertThat(rsp).isEqualTo("[\"jobId\"]");
+ assertThat(rsp).isEqualTo("[]");
}
@Test
- void testGetEiJobTypeNotFound() throws Exception {
- String url = ConsumerConsts.API_ROOT + "/eitypes/junk/eijobs";
- testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find EI type: junk");
+ void a1eGetEiType() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, "test");
+ String url = A1eConsts.API_ROOT + "/eitypes/test";
+ String rsp = restClient().get(url).block();
+ A1eEiTypeInfo info = gson.fromJson(rsp, A1eEiTypeInfo.class);
+ assertThat(info).isNotNull();
}
@Test
- void testGetEiJob() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- putEiJob(EI_TYPE_ID, "jobId");
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/jobId";
+ void consumerGetEiType() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, "test");
+ String url = ConsumerConsts.API_ROOT + "/info-types/test";
String rsp = restClient().get(url).block();
- assertThat(rsp).contains("job_data");
+ ConsumerInfoTypeInfo info = gson.fromJson(rsp, ConsumerInfoTypeInfo.class);
+ assertThat(info).isNotNull();
+ assertThat(info.jobDataSchema).isNotNull();
+ assertThat(info.state).isEqualTo(ConsumerInfoTypeInfo.ConsumerTypeStatusValues.ENABLED);
+ assertThat(info.noOfProducers).isEqualTo(1);
}
@Test
- void testGetEiJobNotFound() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/junk";
- testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find EI job: junk");
+ void a1eGetEiTypeNotFound() throws Exception {
+ String url = A1eConsts.API_ROOT + "/eitypes/junk";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Information type not found: junk");
}
@Test
- void testGetEiJobStatus() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- putEiJob(EI_TYPE_ID, "jobId");
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/jobId/status";
+ void consumerGetEiTypeNotFound() throws Exception {
+ String url = ConsumerConsts.API_ROOT + "/info-types/junk";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Information type not found: junk");
+ }
+
+ @Test
+ void a1eGetEiJobsIds() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ final String JOB_ID_JSON = "[\"jobId\"]";
+ String url = A1eConsts.API_ROOT + "/eijobs?infoTypeId=typeId";
String rsp = restClient().get(url).block();
- assertThat(rsp).contains("ENABLED");
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = A1eConsts.API_ROOT + "/eijobs?owner=owner";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = A1eConsts.API_ROOT + "/eijobs?owner=JUNK";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo("[]");
+
+ url = A1eConsts.API_ROOT + "/eijobs";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = A1eConsts.API_ROOT + "/eijobs?eiTypeId=typeId&&owner=owner";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = A1eConsts.API_ROOT + "/eijobs?eiTypeId=JUNK";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo("[]");
}
- // Status TBD
+ @Test
+ void consumerGetInformationJobsIds() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ final String JOB_ID_JSON = "[\"jobId\"]";
+ String url = ConsumerConsts.API_ROOT + "/info-jobs?infoTypeId=typeId";
+ String rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = ConsumerConsts.API_ROOT + "/info-jobs?owner=owner";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = ConsumerConsts.API_ROOT + "/info-jobs?owner=JUNK";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo("[]");
+
+ url = ConsumerConsts.API_ROOT + "/info-jobs";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = ConsumerConsts.API_ROOT + "/info-jobs?infoTypeId=typeId&&owner=owner";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo(JOB_ID_JSON);
+
+ url = ConsumerConsts.API_ROOT + "/info-jobs?infoTypeId=JUNK";
+ rsp = restClient().get(url).block();
+ assertThat(rsp).isEqualTo("[]");
+ }
+
+ @Test
+ void a1eGetEiJob() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ String url = A1eConsts.API_ROOT + "/eijobs/jobId";
+ String rsp = restClient().get(url).block();
+ A1eEiJobInfo info = gson.fromJson(rsp, A1eEiJobInfo.class);
+ assertThat(info.owner).isEqualTo("owner");
+ assertThat(info.eiTypeId).isEqualTo(TYPE_ID);
+ }
+
+ @Test
+ void consumerGetEiJob() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId";
+ String rsp = restClient().get(url).block();
+ ConsumerJobInfo info = gson.fromJson(rsp, ConsumerJobInfo.class);
+ assertThat(info.owner).isEqualTo("owner");
+ assertThat(info.infoTypeId).isEqualTo(TYPE_ID);
+ }
+
+ @Test
+ void a1eGetEiJobNotFound() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ String url = A1eConsts.API_ROOT + "/eijobs/junk";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find Information job: junk");
+ }
+
+ @Test
+ void consumerGetInfoJobNotFound() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/junk";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find Information job: junk");
+ }
+
+ @Test
+ void a1eGetEiJobStatus() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+
+ verifyJobStatus("jobId", "ENABLED");
+ }
@Test
- void testDeleteEiJob() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- putEiJob(EI_TYPE_ID, "jobId");
- assertThat(this.eiJobs.size()).isEqualTo(1);
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/jobId";
+ void consumerGetEiJobStatus() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId/status";
+ String rsp = restClient().get(url).block();
+ assertThat(rsp) //
+ .contains("ENABLED") //
+ .contains(PRODUCER_ID);
+
+ ConsumerJobStatus status = gson.fromJson(rsp, ConsumerJobStatus.class);
+ assertThat(status.producers).contains(PRODUCER_ID);
+ }
+
+ @Test
+ void a1eDeleteEiJob() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ assertThat(this.infoJobs.size()).isEqualTo(1);
+ String url = A1eConsts.API_ROOT + "/eijobs/jobId";
restClient().delete(url).block();
- assertThat(this.eiJobs.size()).isEqualTo(0);
+ assertThat(this.infoJobs.size()).isZero();
ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
await().untilAsserted(() -> assertThat(simulatorResults.jobsStopped.size()).isEqualTo(1));
- assertThat(simulatorResults.jobsStopped.get(0).id).isEqualTo("jobId");
+ assertThat(simulatorResults.jobsStopped.get(0)).isEqualTo("jobId");
}
@Test
- void testDeleteEiJobNotFound() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/junk";
- testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find EI job: junk");
+ void consumerDeleteEiJob() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ assertThat(this.infoJobs.size()).isEqualTo(1);
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId";
+ restClient().delete(url).block();
+ assertThat(this.infoJobs.size()).isZero();
+
+ ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
+ await().untilAsserted(() -> assertThat(simulatorResults.jobsStopped.size()).isEqualTo(1));
+ assertThat(simulatorResults.jobsStopped.get(0)).isEqualTo("jobId");
+ }
+
+ @Test
+ void a1eDeleteEiJobNotFound() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ String url = A1eConsts.API_ROOT + "/eijobs/junk";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find Information job: junk");
+ }
+
+ @Test
+ void consumerDeleteEiJobNotFound() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/junk";
+ testErrorCode(restClient().get(url), HttpStatus.NOT_FOUND, "Could not find Information job: junk");
+ }
+
+ @Test
+ void a1ePutEiJob() throws Exception {
+ // Test that one producer accepting a job is enough
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiProducerWithOneTypeRejecting("simulateProducerError", TYPE_ID);
+
+ String url = A1eConsts.API_ROOT + "/eijobs/jobId";
+ String body = gson.toJson(infoJobInfo());
+ ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
+ assertThat(this.infoJobs.size()).isEqualTo(1);
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+
+ ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
+ await().untilAsserted(() -> assertThat(simulatorResults.jobsStarted.size()).isEqualTo(1));
+ ProducerJobInfo request = simulatorResults.jobsStarted.get(0);
+ assertThat(request.id).isEqualTo("jobId");
+
+ // One retry --> two calls
+ await().untilAsserted(() -> assertThat(simulatorResults.noOfRejectedCreate).isEqualTo(2));
+ assertThat(simulatorResults.noOfRejectedCreate).isEqualTo(2);
+
+ resp = restClient().putForEntity(url, body).block();
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
+ InfoJob job = this.infoJobs.getJob("jobId");
+ assertThat(job.getOwner()).isEqualTo("owner");
+
+ verifyJobStatus(EI_JOB_ID, "ENABLED");
}
@Test
- void testPutEiJob() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
+ void consumerPutInformationJob() throws Exception {
+ // Test that one producer accepting a job is enough
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/jobId";
- String body = gson.toJson(eiJobInfo());
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId";
+ String body = gson.toJson(consumerJobInfo());
ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
- assertThat(this.eiJobs.size()).isEqualTo(1);
+ assertThat(this.infoJobs.size()).isEqualTo(1);
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.CREATED);
ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
resp = restClient().putForEntity(url, body).block();
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
- EiJob job = this.eiJobs.getJob("jobId");
- assertThat(job.owner()).isEqualTo("owner");
+ InfoJob job = this.infoJobs.getJob("jobId");
+ assertThat(job.getOwner()).isEqualTo("owner");
+
+ verifyJobStatus(EI_JOB_ID, "ENABLED");
+ }
+
+ @Test
+ void consumerPutInformationJob_noType() throws JsonMappingException, JsonProcessingException, ServiceException {
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId?typeCheck=false";
+ String body = gson.toJson(consumerJobInfo());
+ ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
+ assertThat(this.infoJobs.size()).isEqualTo(1);
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+ verifyJobStatus(EI_JOB_ID, "DISABLED");
+
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+
+ verifyJobStatus(EI_JOB_ID, "ENABLED");
+
}
@Test
- void testPutEiJob_jsonSchemavalidationError() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
+ void a1ePutEiJob_jsonSchemavalidationError() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/jobId";
+ String url = A1eConsts.API_ROOT + "/eijobs/jobId";
// The element with name "property1" is mandatory in the schema
- ConsumerEiJobInfo jobInfo =
- new ConsumerEiJobInfo(jsonObject("{ \"XXstring\" : \"value\" }"), "owner", "targetUri");
+ A1eEiJobInfo jobInfo = new A1eEiJobInfo("typeId", jsonObject("{ \"XXstring\" : \"value\" }"), "owner",
+ "targetUri", "jobStatusUrl");
String body = gson.toJson(jobInfo);
- testErrorCode(restClient().put(url, body), HttpStatus.NOT_FOUND, "Json validation failure");
+ testErrorCode(restClient().put(url, body), HttpStatus.CONFLICT, "Json validation failure");
}
@Test
- void testGetEiProducerTypes() throws Exception {
- final String EI_TYPE_ID_2 = EI_TYPE_ID + "_2";
- putEiProducerWithOneType("producer1", EI_TYPE_ID);
- putEiJob(EI_TYPE_ID, "jobId");
- putEiProducerWithOneType("producer2", EI_TYPE_ID_2);
- putEiJob(EI_TYPE_ID_2, "jobId2");
- String url = ProducerConsts.API_ROOT + "/eitypes";
+ void consumerPutJob_jsonSchemavalidationError() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
- ResponseEntity<String> resp = restClient().getForEntity(url).block();
- assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
- assertThat(resp.getBody()).contains(EI_TYPE_ID);
- assertThat(resp.getBody()).contains(EI_TYPE_ID_2);
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId?typeCheck=true";
+ // The element with name "property1" is mandatory in the schema
+ ConsumerJobInfo jobInfo =
+ new ConsumerJobInfo("typeId", jsonObject("{ \"XXstring\" : \"value\" }"), "owner", "targetUri", null);
+ String body = gson.toJson(jobInfo);
+
+ testErrorCode(restClient().put(url, body), HttpStatus.CONFLICT, "Json validation failure");
}
@Test
- void testReplacingEiProducerTypes() throws Exception {
- final String REPLACED_TYPE_ID = "replaced";
- putEiProducerWithOneType(EI_PRODUCER_ID, REPLACED_TYPE_ID);
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
+ void consumerPutJob_uriError() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
- String url = ProducerConsts.API_ROOT + "/eitypes";
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId?typeCheck=true";
- ResponseEntity<String> resp = restClient().getForEntity(url).block();
- assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
- assertThat(resp.getBody()).contains(EI_TYPE_ID);
- assertThat(resp.getBody()).doesNotContain(REPLACED_TYPE_ID);
+ ConsumerJobInfo jobInfo = new ConsumerJobInfo(TYPE_ID, jsonObject(), "owner", "junk", null);
+ String body = gson.toJson(jobInfo);
+
+ testErrorCode(restClient().put(url, body), HttpStatus.CONFLICT, "URI: junk is not absolute");
}
@Test
- void testChangingEiTypeGetRejected() throws Exception {
- putEiProducerWithOneType("producer1", "typeId1");
- putEiProducerWithOneType("producer2", "typeId2");
+ void a1eChangingEiTypeGetRejected() throws Exception {
+ putInfoProducerWithOneType("producer1", "typeId1");
+ putInfoProducerWithOneType("producer2", "typeId2");
putEiJob("typeId1", "jobId");
- String url = ConsumerConsts.API_ROOT + "/eitypes/typeId2/eijobs/jobId";
- String body = gson.toJson(eiJobInfo());
+ String url = A1eConsts.API_ROOT + "/eijobs/jobId";
+ String body = gson.toJson(infoJobInfo("typeId2", "jobId"));
testErrorCode(restClient().put(url, body), HttpStatus.CONFLICT,
"Not allowed to change type for existing EI job");
}
@Test
- void testPutEiProducer() throws Exception {
- String url = ProducerConsts.API_ROOT + "/eiproducers/eiProducerId";
- String body = gson.toJson(producerEiRegistratioInfo(EI_TYPE_ID));
+ void consumerChangingInfoTypeGetRejected() throws Exception {
+ putInfoProducerWithOneType("producer1", "typeId1");
+ putInfoProducerWithOneType("producer2", "typeId2");
+ putEiJob("typeId1", "jobId");
+
+ String url = ConsumerConsts.API_ROOT + "/info-jobs/jobId";
+ String body = gson.toJson(consumerJobInfo("typeId2", "jobId"));
+ testErrorCode(restClient().put(url, body), HttpStatus.CONFLICT, "Not allowed to change type for existing job");
+ }
+
+ @Test
+ void producerPutEiType() throws JsonMappingException, JsonProcessingException, ServiceException {
+ assertThat(putInfoType(TYPE_ID)).isEqualTo(HttpStatus.CREATED);
+ assertThat(putInfoType(TYPE_ID)).isEqualTo(HttpStatus.OK);
+ }
+
+ @Test
+ void producerPutEiType_noSchema() {
+ String url = ProducerConsts.API_ROOT + "/info-types/" + TYPE_ID;
+ String body = "{}";
+ testErrorCode(restClient().put(url, body), HttpStatus.BAD_REQUEST, "No schema provided");
+ }
+
+ @Test
+ void producerDeleteEiType() throws Exception {
+ putInfoType(TYPE_ID);
+ this.putEiJob(TYPE_ID, "job1");
+ this.putEiJob(TYPE_ID, "job2");
+ deleteInfoType(TYPE_ID);
+
+ assertThat(this.infoTypes.size()).isZero();
+ assertThat(this.infoJobs.size()).isZero(); // Test that also the job is deleted
+
+ testErrorCode(restClient().delete(deleteInfoTypeUrl(TYPE_ID)), HttpStatus.NOT_FOUND,
+ "Information type not found");
+ }
+
+ @Test
+ void producerDeleteEiTypeExistingProducer() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ String url = ProducerConsts.API_ROOT + "/info-types/" + TYPE_ID;
+ testErrorCode(restClient().delete(url), HttpStatus.NOT_ACCEPTABLE,
+ "The type has active producers: " + PRODUCER_ID);
+ assertThat(this.infoTypes.size()).isEqualTo(1);
+ }
+
+ @Test
+ void producerPutProducerWithOneType_rejecting()
+ throws JsonMappingException, JsonProcessingException, ServiceException {
+ putEiProducerWithOneTypeRejecting("simulateProducerError", TYPE_ID);
+ String url = A1eConsts.API_ROOT + "/eijobs/" + EI_JOB_ID;
+ String body = gson.toJson(infoJobInfo());
+ restClient().put(url, body).block();
+
+ ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
+ // There is one retry -> 2 calls
+ await().untilAsserted(() -> assertThat(simulatorResults.noOfRejectedCreate).isEqualTo(2));
+ assertThat(simulatorResults.noOfRejectedCreate).isEqualTo(2);
+
+ verifyJobStatus(EI_JOB_ID, "DISABLED");
+ }
+
+ @Test
+ void producerGetEiProducerTypes() throws Exception {
+ final String EI_TYPE_ID_2 = TYPE_ID + "_2";
+ putInfoProducerWithOneType("producer1", TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ putInfoProducerWithOneType("producer2", EI_TYPE_ID_2);
+ putEiJob(EI_TYPE_ID_2, "jobId2");
+ String url = ProducerConsts.API_ROOT + "/info-types";
+
+ ResponseEntity<String> resp = restClient().getForEntity(url).block();
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
+ assertThat(resp.getBody()).contains(TYPE_ID);
+ assertThat(resp.getBody()).contains(EI_TYPE_ID_2);
+ }
+
+ @Test
+ void producerPutEiProducer() throws Exception {
+ this.putInfoType(TYPE_ID);
+ String url = ProducerConsts.API_ROOT + "/info-producers/infoProducerId";
+ String body = gson.toJson(producerInfoRegistratioInfo(TYPE_ID));
ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.CREATED);
- assertThat(this.eiTypes.size()).isEqualTo(1);
- EiType type = this.eiTypes.getType(EI_TYPE_ID);
- assertThat(type.getProducerIds().contains("eiProducerId")).isTrue();
- assertThat(this.eiProducers.size()).isEqualTo(1);
- assertThat(this.eiProducers.get("eiProducerId").eiTypes().iterator().next().getId().equals(EI_TYPE_ID))
- .isTrue();
+ assertThat(this.infoTypes.size()).isEqualTo(1);
+ assertThat(this.infoProducers.getProducersForType(TYPE_ID)).hasSize(1);
+ assertThat(this.infoProducers.size()).isEqualTo(1);
+ assertThat(this.infoProducers.get("infoProducerId").getInfoTypes().iterator().next().getId())
+ .isEqualTo(TYPE_ID);
resp = restClient().putForEntity(url, body).block();
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
}
@Test
- void testPutEiProducerExistingJob() throws Exception {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- putEiJob(EI_TYPE_ID, "jobId");
- String url = ProducerConsts.API_ROOT + "/eiproducers/eiProducerId";
- String body = gson.toJson(producerEiRegistratioInfo(EI_TYPE_ID));
+ void producerPutEiProducerExistingJob() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ String url = ProducerConsts.API_ROOT + "/info-producers/infoProducerId";
+ String body = gson.toJson(producerInfoRegistratioInfo(TYPE_ID));
restClient().putForEntity(url, body).block();
ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
}
@Test
- void testPutProducerAndEiJob() throws Exception {
- String url = ProducerConsts.API_ROOT + "/eiproducers/eiProducerId";
- String body = gson.toJson(producerEiRegistratioInfo(EI_TYPE_ID));
+ void testPutEiProducer_noType() throws Exception {
+ String url = ProducerConsts.API_ROOT + "/info-producers/infoProducerId";
+ String body = gson.toJson(producerInfoRegistratioInfo(TYPE_ID));
+ testErrorCode(restClient().put(url, body), HttpStatus.NOT_FOUND, "Information type not found");
+ }
+
+ @Test
+ void producerPutProducerAndEiJob() throws Exception {
+ this.putInfoType(TYPE_ID);
+ String url = ProducerConsts.API_ROOT + "/info-producers/infoProducerId";
+ String body = gson.toJson(producerInfoRegistratioInfo(TYPE_ID));
restClient().putForEntity(url, body).block();
- assertThat(this.eiTypes.size()).isEqualTo(1);
- this.eiTypes.getType(EI_TYPE_ID);
+ assertThat(this.infoTypes.size()).isEqualTo(1);
+ this.infoTypes.getType(TYPE_ID);
- url = ConsumerConsts.API_ROOT + "/eitypes/typeId/eijobs/jobId";
- body = gson.toJson(eiJobInfo());
+ url = A1eConsts.API_ROOT + "/eijobs/jobId";
+ body = gson.toJson(infoJobInfo());
restClient().putForEntity(url, body).block();
ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
}
@Test
- void testGetEiJobsForProducer() throws JsonMappingException, JsonProcessingException, ServiceException {
- putEiProducerWithOneType(EI_PRODUCER_ID, EI_TYPE_ID);
- putEiJob(EI_TYPE_ID, "jobId1");
- putEiJob(EI_TYPE_ID, "jobId2");
-
- // PUT a consumer
- String url = ProducerConsts.API_ROOT + "/eiproducers/eiProducerId";
- String body = gson.toJson(producerEiRegistratioInfo(EI_TYPE_ID));
+ void producerGetEiJobsForProducer() throws JsonMappingException, JsonProcessingException, ServiceException {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId1");
+ putEiJob(TYPE_ID, "jobId2");
+
+ // PUT a consumerRestApiTestBase.java
+ String url = ProducerConsts.API_ROOT + "/info-producers/infoProducerId";
+ String body = gson.toJson(producerInfoRegistratioInfo(TYPE_ID));
restClient().putForEntity(url, body).block();
- url = ProducerConsts.API_ROOT + "/eiproducers/eiProducerId/eijobs";
+ url = ProducerConsts.API_ROOT + "/info-producers/infoProducerId/info-jobs";
ResponseEntity<String> resp = restClient().getForEntity(url).block();
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
ProducerJobInfo[] parsedResp = gson.fromJson(resp.getBody(), ProducerJobInfo[].class);
- assertThat(parsedResp[0].typeId).isEqualTo(EI_TYPE_ID);
- assertThat(parsedResp[1].typeId).isEqualTo(EI_TYPE_ID);
+ assertThat(parsedResp[0].typeId).isEqualTo(TYPE_ID);
+ assertThat(parsedResp[1].typeId).isEqualTo(TYPE_ID);
}
@Test
- void testDeleteEiProducer() throws Exception {
- String url = ProducerConsts.API_ROOT + "/eiproducers/eiProducerId";
- String url2 = ProducerConsts.API_ROOT + "/eiproducers/eiProducerId2";
- String body = gson.toJson(producerEiRegistratioInfo(EI_TYPE_ID));
- restClient().putForEntity(url, body).block();
- restClient().putForEntity(url2, body).block();
- assertThat(this.eiProducers.size()).isEqualTo(2);
- EiType type = this.eiTypes.getType(EI_TYPE_ID);
- assertThat(type.getProducerIds().contains("eiProducerId")).isTrue();
- assertThat(type.getProducerIds().contains("eiProducerId2")).isTrue();
- putEiJob(EI_TYPE_ID, "jobId");
- assertThat(this.eiJobs.size()).isEqualTo(1);
+ void producerDeleteEiProducer() throws Exception {
+ putInfoProducerWithOneType("infoProducerId", TYPE_ID);
+ putInfoProducerWithOneType("infoProducerId2", TYPE_ID);
+
+ assertThat(this.infoProducers.size()).isEqualTo(2);
+ InfoType type = this.infoTypes.getType(TYPE_ID);
+ assertThat(this.infoProducers.getProducerIdsForType(type.getId())).contains("infoProducerId");
+ assertThat(this.infoProducers.getProducerIdsForType(type.getId())).contains("infoProducerId2");
+ putEiJob(TYPE_ID, "jobId");
+ assertThat(this.infoJobs.size()).isEqualTo(1);
+
+ deleteEiProducer("infoProducerId");
+ assertThat(this.infoProducers.size()).isEqualTo(1);
+ assertThat(this.infoProducers.getProducerIdsForType(TYPE_ID)).doesNotContain("infoProducerId");
+ verifyJobStatus("jobId", "ENABLED");
+
+ deleteEiProducer("infoProducerId2");
+ assertThat(this.infoProducers.size()).isZero();
+ assertThat(this.infoTypes.size()).isEqualTo(1);
+ verifyJobStatus("jobId", "DISABLED");
+ }
+
+ @Test
+ void a1eJobStatusNotifications() throws JsonMappingException, JsonProcessingException, ServiceException {
+ ConsumerSimulatorController.TestResults consumerCalls = this.consumerSimulator.getTestResults();
+ ProducerSimulatorController.TestResults producerCalls = this.producerSimulator.getTestResults();
+
+ putInfoProducerWithOneType("infoProducerId", TYPE_ID);
+ putEiJob(TYPE_ID, "jobId");
+ putInfoProducerWithOneType("infoProducerId2", TYPE_ID);
+ await().untilAsserted(() -> assertThat(producerCalls.jobsStarted.size()).isEqualTo(2));
+
+ deleteEiProducer("infoProducerId2");
+ assertThat(this.infoTypes.size()).isEqualTo(1); // The type remains, one producer left
+ deleteEiProducer("infoProducerId");
+ assertThat(this.infoTypes.size()).isEqualTo(1); // The type remains
+ assertThat(this.infoJobs.size()).isEqualTo(1); // The job remains
+ await().untilAsserted(() -> assertThat(consumerCalls.eiJobStatusCallbacks.size()).isEqualTo(1));
+ assertThat(consumerCalls.eiJobStatusCallbacks.get(0).state)
+ .isEqualTo(A1eEiJobStatus.EiJobStatusValues.DISABLED);
+
+ putInfoProducerWithOneType("infoProducerId", TYPE_ID);
+ await().untilAsserted(() -> assertThat(consumerCalls.eiJobStatusCallbacks.size()).isEqualTo(2));
+ assertThat(consumerCalls.eiJobStatusCallbacks.get(1).state).isEqualTo(A1eEiJobStatus.EiJobStatusValues.ENABLED);
+ }
+
+ @Test
+ void a1eJobStatusNotifications2() throws JsonMappingException, JsonProcessingException, ServiceException {
+ // Test replacing a producer with new and removed types
+
+ // Create a job
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, EI_JOB_ID);
+
+ // change the type for the producer, the job shall be disabled
+ putInfoProducerWithOneType(PRODUCER_ID, "junk");
+ verifyJobStatus(EI_JOB_ID, "DISABLED");
+ ConsumerSimulatorController.TestResults consumerCalls = this.consumerSimulator.getTestResults();
+ await().untilAsserted(() -> assertThat(consumerCalls.eiJobStatusCallbacks.size()).isEqualTo(1));
+ assertThat(consumerCalls.eiJobStatusCallbacks.get(0).state)
+ .isEqualTo(A1eEiJobStatus.EiJobStatusValues.DISABLED);
+
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ verifyJobStatus(EI_JOB_ID, "ENABLED");
+ await().untilAsserted(() -> assertThat(consumerCalls.eiJobStatusCallbacks.size()).isEqualTo(2));
+ assertThat(consumerCalls.eiJobStatusCallbacks.get(1).state).isEqualTo(A1eEiJobStatus.EiJobStatusValues.ENABLED);
+ }
+
+ @Test
+ void producerGetProducerEiType() throws JsonMappingException, JsonProcessingException, ServiceException {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ String url = ProducerConsts.API_ROOT + "/info-types/" + TYPE_ID;
+ ResponseEntity<String> resp = restClient().getForEntity(url).block();
+ ProducerInfoTypeInfo info = gson.fromJson(resp.getBody(), ProducerInfoTypeInfo.class);
+ assertThat(info.jobDataSchema).isNotNull();
+ }
+
+ @Test
+ void producerGetProducerIdentifiers() throws JsonMappingException, JsonProcessingException, ServiceException {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ String url = ProducerConsts.API_ROOT + "/info-producers";
+ ResponseEntity<String> resp = restClient().getForEntity(url).block();
+ assertThat(resp.getBody()).contains(PRODUCER_ID);
+
+ url = ProducerConsts.API_ROOT + "/info-producers?info_type_id=" + TYPE_ID;
+ resp = restClient().getForEntity(url).block();
+ assertThat(resp.getBody()).contains(PRODUCER_ID);
+
+ url = ProducerConsts.API_ROOT + "/info-producers?info_type_id=junk";
+ resp = restClient().getForEntity(url).block();
+ assertThat(resp.getBody()).isEqualTo("[]");
+ }
+
+ @Test
+ void producerSupervision() throws JsonMappingException, JsonProcessingException, ServiceException {
+
+ ConsumerSimulatorController.TestResults consumerResults = this.consumerSimulator.getTestResults();
+ putEiProducerWithOneTypeRejecting("simulateProducerError", TYPE_ID);
+
+ {
+ // Create a job
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, EI_JOB_ID);
+ verifyJobStatus(EI_JOB_ID, "ENABLED");
+ deleteEiProducer(PRODUCER_ID);
+ // A Job disabled status notification shall now be received
+ await().untilAsserted(() -> assertThat(consumerResults.eiJobStatusCallbacks.size()).isEqualTo(1));
+ assertThat(consumerResults.eiJobStatusCallbacks.get(0).state)
+ .isEqualTo(A1eEiJobStatus.EiJobStatusValues.DISABLED);
+ verifyJobStatus(EI_JOB_ID, "DISABLED");
+ }
+
+ assertThat(this.infoProducers.size()).isEqualTo(1);
+ assertThat(this.infoTypes.size()).isEqualTo(1);
+ assertProducerOpState("simulateProducerError", ProducerStatusInfo.OperationalState.ENABLED);
+
+ this.producerSupervision.createTask().blockLast();
+ this.producerSupervision.createTask().blockLast();
+
+ // Now we have one producer that is disabled
+ assertThat(this.infoProducers.size()).isEqualTo(1);
+ assertProducerOpState("simulateProducerError", ProducerStatusInfo.OperationalState.DISABLED);
+
+ // After 3 failed checks, the producer shall be deregistered
+ this.producerSupervision.createTask().blockLast();
+ assertThat(this.infoProducers.size()).isZero(); // The producer is removed
+ assertThat(this.infoTypes.size()).isEqualTo(1); // The type remains
+
+ // Now we have one disabled job, and no producer.
+ // PUT a producer, then a Job ENABLED status notification shall be received
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ await().untilAsserted(() -> assertThat(consumerResults.eiJobStatusCallbacks.size()).isEqualTo(2));
+ assertThat(consumerResults.eiJobStatusCallbacks.get(1).state)
+ .isEqualTo(A1eEiJobStatus.EiJobStatusValues.ENABLED);
+ verifyJobStatus(EI_JOB_ID, "ENABLED");
+ }
+
+ @Test
+ void producerSupervision2() throws JsonMappingException, JsonProcessingException, ServiceException {
+ // Test that supervision enables not enabled jobs and sends a notification when
+ // suceeded
+
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, EI_JOB_ID);
+
+ InfoProducer producer = this.infoProducers.getProducer(PRODUCER_ID);
+ InfoJob job = this.infoJobs.getJob(EI_JOB_ID);
+ // Pretend that the producer did reject the job and the a DISABLED notification
+ // is sent for the job
+ producer.setJobDisabled(job);
+ job.setLastReportedStatus(false);
+ verifyJobStatus(EI_JOB_ID, "DISABLED");
+
+ // Run the supervision and wait for the job to get started in the producer
+ this.producerSupervision.createTask().blockLast();
+ ConsumerSimulatorController.TestResults consumerResults = this.consumerSimulator.getTestResults();
+ await().untilAsserted(() -> assertThat(consumerResults.eiJobStatusCallbacks.size()).isEqualTo(1));
+ assertThat(consumerResults.eiJobStatusCallbacks.get(0).state)
+ .isEqualTo(A1eEiJobStatus.EiJobStatusValues.ENABLED);
+ verifyJobStatus(EI_JOB_ID, "ENABLED");
+ }
+
+ @Test
+ void testGetStatus() throws JsonMappingException, JsonProcessingException, ServiceException {
+ putEiProducerWithOneTypeRejecting("simulateProducerError", TYPE_ID);
+ putEiProducerWithOneTypeRejecting("simulateProducerError2", TYPE_ID);
+
+ String url = "/status";
+ ResponseEntity<String> resp = restClient().getForEntity(url).block();
+ assertThat(resp.getBody()).contains("hunky dory");
+ }
+
+ @Test
+ void testEiJobDatabase() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+ putEiJob(TYPE_ID, "jobId1");
+ putEiJob(TYPE_ID, "jobId2");
+
+ assertThat(this.infoJobs.size()).isEqualTo(2);
+
+ {
+ InfoJob savedJob = this.infoJobs.getJob("jobId1");
+ // Restore the jobs
+ InfoJobs jobs = new InfoJobs(this.applicationConfig, this.producerCallbacks);
+ jobs.restoreJobsFromDatabase();
+ assertThat(jobs.size()).isEqualTo(2);
+ InfoJob restoredJob = jobs.getJob("jobId1");
+ assertThat(restoredJob.getId()).isEqualTo("jobId1");
+ assertThat(restoredJob.getLastUpdated()).isEqualTo(savedJob.getLastUpdated());
+
+ jobs.remove("jobId1", this.infoProducers);
+ jobs.remove("jobId2", this.infoProducers);
+ }
+ {
+ // Restore the jobs, no jobs in database
+ InfoJobs jobs = new InfoJobs(this.applicationConfig, this.producerCallbacks);
+ jobs.restoreJobsFromDatabase();
+ assertThat(jobs.size()).isZero();
+ }
+ logger.warn("Test removing a job when the db file is gone");
+ this.infoJobs.remove("jobId1", this.infoProducers);
+ assertThat(this.infoJobs.size()).isEqualTo(1);
+ ProducerSimulatorController.TestResults simulatorResults = this.producerSimulator.getTestResults();
+ await().untilAsserted(() -> assertThat(simulatorResults.jobsStopped.size()).isEqualTo(3));
+ }
+
+ @Test
+ void testEiTypesDatabase() throws Exception {
+ putInfoProducerWithOneType(PRODUCER_ID, TYPE_ID);
+
+ assertThat(this.infoTypes.size()).isEqualTo(1);
+
+ {
+ // Restore the types
+ InfoTypes types = new InfoTypes(this.applicationConfig);
+ types.restoreTypesFromDatabase();
+ assertThat(types.size()).isEqualTo(1);
+
+ }
+ {
+ // Restore the jobs, no jobs in database
+ InfoTypes types = new InfoTypes(this.applicationConfig);
+ types.clear();
+ types.restoreTypesFromDatabase();
+ assertThat(types.size()).isZero();
+ }
+ logger.warn("Test removing a job when the db file is gone");
+ this.infoTypes.remove(this.infoTypes.getType(TYPE_ID));
+ assertThat(this.infoJobs.size()).isZero();
+ }
+
+ @Test
+ void testConsumerTypeSubscription() throws Exception {
+
+ final String callbackUrl = baseUrl() + ConsumerSimulatorController.getTypeStatusCallbackUrl();
+ final ConsumerTypeSubscriptionInfo info = new ConsumerTypeSubscriptionInfo(callbackUrl, "owner");
+
+ {
+ // PUT a subscription
+ String body = gson.toJson(info);
+ ResponseEntity<String> resp =
+ restClient().putForEntity(typeSubscriptionUrl() + "/subscriptionId", body).block();
+ assertThat(this.infoTypeSubscriptions.size()).isEqualTo(1);
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+ resp = restClient().putForEntity(typeSubscriptionUrl() + "/subscriptionId", body).block();
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
+ }
+ {
+ // GET IDs
+ ResponseEntity<String> resp = restClient().getForEntity(typeSubscriptionUrl()).block();
+ assertThat(resp.getBody()).isEqualTo("[\"subscriptionId\"]");
+ resp = restClient().getForEntity(typeSubscriptionUrl() + "?owner=owner").block();
+ assertThat(resp.getBody()).isEqualTo("[\"subscriptionId\"]");
+ resp = restClient().getForEntity(typeSubscriptionUrl() + "?owner=junk").block();
+ assertThat(resp.getBody()).isEqualTo("[]");
+ }
+
+ {
+ // GET the individual subscription
+ ResponseEntity<String> resp = restClient().getForEntity(typeSubscriptionUrl() + "/subscriptionId").block();
+ ConsumerTypeSubscriptionInfo respInfo = gson.fromJson(resp.getBody(), ConsumerTypeSubscriptionInfo.class);
+ assertThat(respInfo).isEqualTo(info);
+ }
+
+ {
+ // Test the callbacks
+ final ConsumerSimulatorController.TestResults consumerCalls = this.consumerSimulator.getTestResults();
+
+ // Test callback for PUT type
+ this.putInfoType(TYPE_ID);
+ await().untilAsserted(() -> assertThat(consumerCalls.typeRegistrationInfoCallbacks.size()).isEqualTo(1));
+ assertThat(consumerCalls.typeRegistrationInfoCallbacks.get(0).state)
+ .isEqualTo(ConsumerTypeRegistrationInfo.ConsumerTypeStatusValues.REGISTERED);
+
+ // Test callback for DELETE type
+ this.deleteInfoType(TYPE_ID);
+ await().untilAsserted(() -> assertThat(consumerCalls.typeRegistrationInfoCallbacks.size()).isEqualTo(2));
+ assertThat(consumerCalls.typeRegistrationInfoCallbacks.get(1).state)
+ .isEqualTo(ConsumerTypeRegistrationInfo.ConsumerTypeStatusValues.DEREGISTERED);
+ }
+
+ {
+ // DELETE the subscription
+ ResponseEntity<String> resp =
+ restClient().deleteForEntity(typeSubscriptionUrl() + "/subscriptionId").block();
+ assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
+ assertThat(this.infoTypeSubscriptions.size()).isZero();
+ resp = restClient().getForEntity(typeSubscriptionUrl()).block();
+ assertThat(resp.getBody()).isEqualTo("[]");
+ }
+ }
+
+ @Test
+ void testTypeSubscriptionErrorCodes() throws Exception {
+
+ testErrorCode(restClient().get(typeSubscriptionUrl() + "/junk"), HttpStatus.NOT_FOUND,
+ "Could not find Information subscription: junk");
+
+ testErrorCode(restClient().delete(typeSubscriptionUrl() + "/junk"), HttpStatus.NOT_FOUND,
+ "Could not find Information subscription: junk");
+ }
+
+ private String typeSubscriptionUrl() {
+ return ConsumerConsts.API_ROOT + "/info-type-subscription";
+ }
+
+ private void deleteEiProducer(String infoProducerId) {
+ String url = ProducerConsts.API_ROOT + "/info-producers/" + infoProducerId;
restClient().deleteForEntity(url).block();
- assertThat(this.eiProducers.size()).isEqualTo(1);
- assertThat(this.eiTypes.getType(EI_TYPE_ID).getProducerIds().contains("eiProducerId")).isFalse();
- assertThat(this.eiJobs.size()).isEqualTo(1);
+ }
- restClient().deleteForEntity(url2).block();
- assertThat(this.eiProducers.size()).isEqualTo(0);
- assertThat(this.eiTypes.size()).isEqualTo(0);
- assertThat(this.eiJobs.size()).isEqualTo(0);
+ private void verifyJobStatus(String jobId, String expStatus) {
+ String url = A1eConsts.API_ROOT + "/eijobs/" + jobId + "/status";
+ String rsp = restClient().get(url).block();
+ assertThat(rsp).contains(expStatus);
+ }
+
+ private void assertProducerOpState(String producerId,
+ ProducerStatusInfo.OperationalState expectedOperationalState) {
+ String statusUrl = ProducerConsts.API_ROOT + "/info-producers/" + producerId + "/status";
+ ResponseEntity<String> resp = restClient().getForEntity(statusUrl).block();
+ ProducerStatusInfo statusInfo = gson.fromJson(resp.getBody(), ProducerStatusInfo.class);
+ assertThat(statusInfo.opState).isEqualTo(expectedOperationalState);
+ }
+
+ ProducerInfoTypeInfo producerEiTypeRegistrationInfo(String typeId)
+ throws JsonMappingException, JsonProcessingException {
+ return new ProducerInfoTypeInfo(jsonSchemaObject());
}
- ProducerEiTypeRegistrationInfo producerEiTypeRegistrationInfo(String typeId)
+ ProducerRegistrationInfo producerEiRegistratioInfoRejecting(String typeId)
throws JsonMappingException, JsonProcessingException {
- return new ProducerEiTypeRegistrationInfo(jsonSchemaObject(), typeId);
+ return new ProducerRegistrationInfo(Arrays.asList(typeId), //
+ baseUrl() + ProducerSimulatorController.JOB_ERROR_URL,
+ baseUrl() + ProducerSimulatorController.SUPERVISION_ERROR_URL);
}
- ProducerRegistrationInfo producerEiRegistratioInfo(String typeId)
+ ProducerRegistrationInfo producerInfoRegistratioInfo(String typeId)
throws JsonMappingException, JsonProcessingException {
- Collection<ProducerEiTypeRegistrationInfo> types = new ArrayList<>();
- types.add(producerEiTypeRegistrationInfo(typeId));
- return new ProducerRegistrationInfo(types, baseUrl() + ProducerSimulatorController.JOB_CREATED_URL,
- baseUrl() + ProducerSimulatorController.JOB_DELETED_URL);
+ return new ProducerRegistrationInfo(Arrays.asList(typeId), //
+ baseUrl() + ProducerSimulatorController.JOB_URL, baseUrl() + ProducerSimulatorController.SUPERVISION_URL);
}
- ConsumerEiJobInfo eiJobInfo() throws JsonMappingException, JsonProcessingException {
- return new ConsumerEiJobInfo(jsonObject(), "owner", "targetUri");
+ private ConsumerJobInfo consumerJobInfo() throws JsonMappingException, JsonProcessingException {
+ return consumerJobInfo(TYPE_ID, EI_JOB_ID);
}
- Object jsonObject(String json) {
+ ConsumerJobInfo consumerJobInfo(String typeId, String infoJobId)
+ throws JsonMappingException, JsonProcessingException {
+ return new ConsumerJobInfo(typeId, jsonObject(), "owner", "https://junk.com",
+ baseUrl() + ConsumerSimulatorController.getJobStatusUrl(infoJobId));
+ }
+
+ private A1eEiJobInfo infoJobInfo() throws JsonMappingException, JsonProcessingException {
+ return infoJobInfo(TYPE_ID, EI_JOB_ID);
+ }
+
+ A1eEiJobInfo infoJobInfo(String typeId, String infoJobId) throws JsonMappingException, JsonProcessingException {
+ return new A1eEiJobInfo(typeId, jsonObject(), "owner", "https://junk.com",
+ baseUrl() + ConsumerSimulatorController.getJobStatusUrl(infoJobId));
+ }
+
+ private Object jsonObject(String json) {
try {
return JsonParser.parseString(json).getAsJsonObject();
} catch (Exception e) {
}
}
- Object jsonSchemaObject() {
+ private Object jsonSchemaObject() {
// a json schema with one mandatory property named "string"
String schemaStr = "{" //
+ "\"$schema\": \"http://json-schema.org/draft-04/schema#\"," //
return jsonObject(schemaStr);
}
- Object jsonObject() {
+ private Object jsonObject() {
return jsonObject("{ " + EI_JOB_PROPERTY + " : \"value\" }");
}
- private EiJob putEiJob(String eiTypeId, String jobId)
+ private InfoJob putEiJob(String infoTypeId, String jobId)
throws JsonMappingException, JsonProcessingException, ServiceException {
- String url = ConsumerConsts.API_ROOT + "/eitypes/" + eiTypeId + "/eijobs/" + jobId;
- String body = gson.toJson(eiJobInfo());
+ String url = A1eConsts.API_ROOT + "/eijobs/" + jobId;
+ String body = gson.toJson(infoJobInfo(infoTypeId, jobId));
restClient().putForEntity(url, body).block();
- return this.eiJobs.getJob(jobId);
+ return this.infoJobs.getJob(jobId);
+ }
+
+ private HttpStatus putInfoType(String infoTypeId)
+ throws JsonMappingException, JsonProcessingException, ServiceException {
+ String url = ProducerConsts.API_ROOT + "/info-types/" + infoTypeId;
+ String body = gson.toJson(producerEiTypeRegistrationInfo(infoTypeId));
+
+ ResponseEntity<String> resp = restClient().putForEntity(url, body).block();
+ this.infoTypes.getType(infoTypeId);
+ return resp.getStatusCode();
+ }
+
+ private String deleteInfoTypeUrl(String typeId) {
+ return ProducerConsts.API_ROOT + "/info-types/" + typeId;
+ }
+
+ private void deleteInfoType(String typeId) {
+ restClient().delete(deleteInfoTypeUrl(typeId)).block();
}
- private EiType putEiProducerWithOneType(String producerId, String eiTypeId)
+ private InfoType putEiProducerWithOneTypeRejecting(String producerId, String infoTypeId)
throws JsonMappingException, JsonProcessingException, ServiceException {
- String url = ProducerConsts.API_ROOT + "/eiproducers/" + producerId;
- String body = gson.toJson(producerEiRegistratioInfo(eiTypeId));
+ this.putInfoType(infoTypeId);
+ String url = ProducerConsts.API_ROOT + "/info-producers/" + producerId;
+ String body = gson.toJson(producerEiRegistratioInfoRejecting(infoTypeId));
+ restClient().putForEntity(url, body).block();
+ return this.infoTypes.getType(infoTypeId);
+ }
+
+ private InfoType putInfoProducerWithOneType(String producerId, String infoTypeId)
+ throws JsonMappingException, JsonProcessingException, ServiceException {
+ this.putInfoType(infoTypeId);
+
+ String url = ProducerConsts.API_ROOT + "/info-producers/" + producerId;
+ String body = gson.toJson(producerInfoRegistratioInfo(infoTypeId));
restClient().putForEntity(url, body).block();
- return this.eiTypes.getType(eiTypeId);
+
+ return this.infoTypes.getType(infoTypeId);
}
private String baseUrl() {
private AsyncRestClient restClient(boolean useTrustValidation) {
WebClientConfig config = this.applicationConfig.getWebClientConfig();
+ HttpProxyConfig httpProxyConfig = ImmutableHttpProxyConfig.builder() //
+ .httpProxyHost("") //
+ .httpProxyPort(0) //
+ .build();
config = ImmutableWebClientConfig.builder() //
.keyStoreType(config.keyStoreType()) //
.keyStorePassword(config.keyStorePassword()) //
.isTrustStoreUsed(useTrustValidation) //
.trustStore(config.trustStore()) //
.trustStorePassword(config.trustStorePassword()) //
- .build();
+ .httpProxyConfig(httpProxyConfig).build();
- return new AsyncRestClient(baseUrl(), config);
+ AsyncRestClientFactory restClientFactory = new AsyncRestClientFactory(config);
+ return restClientFactory.createRestClientNoHttpProxy(baseUrl());
}
private AsyncRestClient restClient() {
Code Review / nonrtric.git / blobdiff