package org.onap.nbi.apis;
-import static org.assertj.core.api.Assertions.assertThat;
+import com.github.tomakehurst.wiremock.WireMockServer;
+import com.github.tomakehurst.wiremock.http.ResponseDefinition;
+import com.github.tomakehurst.wiremock.stubbing.ListStubMappingsResult;
+import com.github.tomakehurst.wiremock.stubbing.StubMapping;
import java.util.ArrayList;
+import java.util.Calendar;
import java.util.Date;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Test;
+
+import org.junit.*;
import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.onap.nbi.apis.assertions.HubAssertions;
import org.onap.nbi.apis.assertions.ServiceCatalogAssertions;
import org.onap.nbi.apis.assertions.ServiceInventoryAssertions;
import org.onap.nbi.apis.assertions.ServiceOrderAssertions;
+import org.onap.nbi.apis.hub.HubResource;
+import org.onap.nbi.apis.hub.model.Subscriber;
+import org.onap.nbi.apis.hub.model.Subscription;
+import org.onap.nbi.apis.hub.service.SubscriptionService;
import org.onap.nbi.apis.servicecatalog.ServiceSpecificationResource;
import org.onap.nbi.apis.serviceinventory.ServiceInventoryResource;
import org.onap.nbi.apis.serviceorder.ServiceOrderResource;
-import org.onap.nbi.apis.serviceorder.model.ActionType;
-import org.onap.nbi.apis.serviceorder.model.RelatedParty;
-import org.onap.nbi.apis.serviceorder.model.Service;
-import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
-import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
-import org.onap.nbi.apis.serviceorder.model.StateType;
+import org.onap.nbi.apis.serviceorder.model.*;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
-import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderInfoRepository;
import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.embedded.LocalServerPort;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
+import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
-import com.github.tomakehurst.wiremock.WireMockServer;
-import com.github.tomakehurst.wiremock.stubbing.ListStubMappingsResult;
-import com.github.tomakehurst.wiremock.stubbing.StubMapping;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import static org.assertj.core.api.Assertions.assertThat;
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
ServiceOrderResource serviceOrderResource;
@Autowired
- ServiceOrderRepository serviceOrderRepository;
+ HubResource hubResource;
+
+ @Autowired
+ SubscriptionService subscriptionService;
@Autowired
- ServiceOrderInfoRepository serviceOrderInfoRepository;
+ ServiceOrderRepository serviceOrderRepository;
@Autowired
ExecutionTaskRepository executionTaskRepository;
@Autowired
SOTaskProcessor SoTaskProcessor;
+ @Mock
+ private RequestAttributes attrs;
+
static Validator validator;
+ @Value("${scheduler.pollingDurationInMins}")
+ private float pollingDurationInMins;
+
+ @Before
+ public void before() {
+ MockHttpServletRequest request = new MockHttpServletRequest();
+ RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
+ }
+
@BeforeClass
public static void setUp() throws Exception {
wireMockServer.start();
@After
public void tearsDownUpPort() throws Exception {
executionTaskRepository.deleteAll();
- serviceOrderInfoRepository.deleteAll();
serviceOrderRepository.deleteAll();
+ subscriptionService.deleteAll();
wireMockServer.resetToDefaultMappings();
}
return null;
}
+ private void removeWireMockMapping(String s) {
+ ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
+ StubMapping mappingToDelete = null;
+ List<StubMapping> mappings = listStubMappingsResult.getMappings();
+ for (StubMapping mapping : mappings) {
+ if (mapping.getRequest().getUrl().equals(s)) {
+ mappingToDelete = mapping;
+ }
+
+
+ }
+
+ wireMockServer.removeStubMapping(mappingToDelete);
+ }
+
+ private void changeWireMockResponse(String s,int statusCode, String bodyContent) {
+ ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
+ ResponseDefinition responseDefinition = new ResponseDefinition(statusCode,bodyContent);
+ List<StubMapping> mappings = listStubMappingsResult.getMappings();
+ for (StubMapping mapping : mappings) {
+ if (mapping.getRequest().getUrl().equals(s)) {
+ mapping.setResponse(responseDefinition);
+ }
+ }
+ }
+
+
+
+
// serviceCatalog
+
@Test
@Ignore
public void testServiceResourceGetCatalog() throws Exception {
ResponseEntity<Object> resource =
- serviceSpecificationResource.getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
+ serviceSpecificationResource.getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
ServiceCatalogAssertions.assertGetServiceCatalog(resource);
}
public void testServiceCatalogGetResourceWithoutTosca() throws Exception {
ResponseEntity<Object> resource = serviceSpecificationResource
- .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439_withoutTosca", null);
- ServiceCatalogAssertions.asserGetServiceCatalogWithoutTosca(resource);
+ .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439_withoutTosca", null);
+ ServiceCatalogAssertions.assertGetServiceCatalogWithoutTosca(resource);
}
}
+ @Test
+ public void testServiceResourceGetInventoryWithStatus() throws Exception {
+
+ String serviceName = "AnsibleService";
+ String serviceId = "405c8c00-44b9-4303-9f27-6797d22ca096";
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("serviceSpecification.name", serviceName);
+ params.add("relatedParty.id", "6490");
+ ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
+ LinkedHashMap service = (LinkedHashMap) resource.getBody();
+ assertThat(service.get("state")).isEqualTo("Active");
+
+
+ }
+
@Test
public void testServiceResourceGetInventoryWithoutRelationShipList() throws Exception {
}
+
+ @Test
+ public void testCheckServiceOrderWithUnknownSverviceSpecId() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.getService().getServiceSpecification().setId("toto");
+ }
+
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
+ }
+ }
+
@Test
public void testCheckServiceOrderWithGenericCustomer() throws Exception {
}
+
+ @Test
+ public void testCheckServiceOrderWithoutRelatedParty() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ testServiceOrder.setRelatedParty(null);
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+
+
+ }
+
@Test
- public void testCheckServiceOrderWithUnKnonwCustomer() throws Exception {
+ public void testCheckServiceOrderWithUnKnownCustomer() throws Exception {
ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
List<RelatedParty> customers = new ArrayList<>();
}
@Test
- public void testCheckServiceOrderDelete() throws Exception {
+ public void testCheckServiceOrderInDeleteWithNoServiceId() throws Exception {
ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
- testServiceOrder.setState(StateType.ACKNOWLEDGED);
- testServiceOrder.setId("test");
for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
- serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+ serviceOrderItem.getService().setId(null);
}
+
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
serviceOrderRepository.save(testServiceOrder);
serviceOrderResource.scheduleCheckServiceOrders();
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
- assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("101");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
+ }
}
+
@Test
- public void testCheckServiceOrderDeleteRejected() throws Exception {
+ public void testCheckServiceOrderInModifyWithNoServiceId() throws Exception {
- ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.MODIFY);
for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
- serviceOrderItem.getService().setId("no_response");
-
+ serviceOrderItem.getService().setId(null);
}
+
testServiceOrder.setState(StateType.ACKNOWLEDGED);
testServiceOrder.setId("test");
serviceOrderRepository.save(testServiceOrder);
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("101");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
+ }
}
@Test
- public void testCheckServiceOrderNoChange() throws Exception {
+ public void testCheckServiceOrderInAddWithServiceId() throws Exception {
- ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
- serviceOrderItem.setAction(ActionType.NOCHANGE);
+ serviceOrderItem.getService().setId("toto");
}
testServiceOrder.setState(StateType.ACKNOWLEDGED);
serviceOrderResource.scheduleCheckServiceOrders();
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
- assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+
for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
- assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("103");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
}
-
}
-
-
@Test
- public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
+ public void testCheckServiceOrderWithUnKnownCustomerInChange() throws Exception {
ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
- for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
- if (serviceOrderItem.getId().equals("A")) {
- serviceOrderItem.setAction(ActionType.NOCHANGE);
- }
- serviceOrderItem.setState(StateType.ACKNOWLEDGED);
- }
-
+ List<RelatedParty> customers = new ArrayList<>();
+ RelatedParty customer = new RelatedParty();
+ customer.setId("new");
+ customer.setRole("ONAPcustomer");
+ customer.setName("romain");
+ customers.add(customer);
+ testServiceOrder.setRelatedParty(customers);
testServiceOrder.setState(StateType.ACKNOWLEDGED);
testServiceOrder.setId("test");
serviceOrderRepository.save(testServiceOrder);
serviceOrderResource.scheduleCheckServiceOrders();
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
- assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
- for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
- if (serviceOrderItem.getId().equals("A"))
- assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
- }
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+
+ assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("104");
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getField()).isEqualTo("relatedParty.id");
}
@Test
- public void testCheckServiceOrderRejected() throws Exception {
+ public void testCheckServiceOrderWithCustomerAAINotResponding() throws Exception {
+ removeWireMockMapping("/aai/v11/business/customers/customer/new");
- ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ List<RelatedParty> customers = new ArrayList<>();
+ RelatedParty customer = new RelatedParty();
+ customer.setId("new");
+ customer.setRole("ONAPcustomer");
+ customer.setName("romain");
+ customers.add(customer);
+ testServiceOrder.setRelatedParty(customers);
testServiceOrder.setState(StateType.ACKNOWLEDGED);
testServiceOrder.setId("test");
serviceOrderRepository.save(testServiceOrder);
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
- }
-
- @Test
- public void validateServiceOrderBeanWithAnnotation() {
- ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
- Set violations = validator.validate(serviceOrder);
- assertThat(violations).isEmpty();
-
- ServiceOrderItem item = new ServiceOrderItem();
- item.setAction(ActionType.DELETE);
- item.setService(new Service());
- serviceOrder.addOrderItemItem(item);
- violations = validator.validate(serviceOrder);
- assertThat(violations).isNotEmpty();
+ assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("501");
+ assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation()).isEqualTo("Problem with AAI API");
}
-
@Test
- public void testFindAndGetServiceOrder() throws Exception {
+ public void testCheckServiceOrderWithSDCNotResponding() throws Exception {
+
+ removeWireMockMapping("/sdc/v1/catalog/services/1e3feeb0-8e36-46c6-862c-236d9c626439/metadata");
ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
- for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
- serviceOrderItem.setState(StateType.ACKNOWLEDGED);
- }
- testServiceOrder.setExternalId("extid1");
- testServiceOrder.setOrderDate(new Date());
+ List<RelatedParty> customers = new ArrayList<>();
+ RelatedParty customer = new RelatedParty();
+ customer.setId("new");
+ customer.setRole("ONAPcustomer");
+ customer.setName("romain");
+ customers.add(customer);
+ testServiceOrder.setRelatedParty(customers);
testServiceOrder.setState(StateType.ACKNOWLEDGED);
- testServiceOrder.setDescription("toto");
testServiceOrder.setId("test");
serviceOrderRepository.save(testServiceOrder);
+ serviceOrderResource.scheduleCheckServiceOrders();
- ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
- testServiceOrder2.setState(StateType.ACKNOWLEDGED);
- testServiceOrder2.setDescription("toto");
- testServiceOrder2.setId("test2");
- testServiceOrder2.setExternalId("extid2");
- testServiceOrder2.setOrderDate(new Date());
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
- serviceOrderRepository.save(testServiceOrder2);
+
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
+ }
+ }
- MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
- params.add("fields", "id");
- ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
- ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
- assertThat(serviceOrders.size()).isEqualTo(2);
- params.add("externalId", "extid1");
- params.add("state", "acknowledged");
+ @Test
+ public void testCheckServiceOrderWithPutServiceAAINotResponding() throws Exception {
- serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
- serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
- assertThat(serviceOrders.size()).isEqualTo(1);
+ removeWireMockMapping("/aai/v11/business/customers/customer/new/service-subscriptions/service-subscription/vFW");
- MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
- paramsDate.add("orderDate.gt", "2017-01-01 00:00:00.000");
- paramsDate.add("orderDate.lt", "2030-01-01 00:00:00.000");
- paramsDate.add("offset", "0");
- paramsDate.add("limit", "2");
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ List<RelatedParty> customers = new ArrayList<>();
+ RelatedParty customer = new RelatedParty();
+ customer.setId("new");
+ customer.setRole("ONAPcustomer");
+ customer.setName("romain");
+ customers.add(customer);
+ testServiceOrder.setRelatedParty(customers);
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
- serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
- serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
- assertThat(serviceOrders.size()).isEqualTo(2);
+ serviceOrderResource.scheduleCheckServiceOrders();
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
- ResponseEntity<Object> serviceOrderResponse =
- serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
- ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
- assertThat(serviceOrder).isNotNull();
}
-
@Test
- public void testExecutionTaskSuccess() throws Exception {
+ public void testCheckServiceOrderDelete() throws Exception {
- ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
- serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
- ExecutionTask executionTaskB;
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+ }
+ serviceOrderRepository.save(testServiceOrder);
+ serviceOrderResource.scheduleCheckServiceOrders();
- SoTaskProcessor.processOrderItem(executionTaskA);
ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
- assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
- for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
- if (serviceOrderItem.getId().equals("A")) {
- assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
- } else {
- assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
- }
- }
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
- executionTaskB = getExecutionTask("B");
- assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
- executionTaskA = getExecutionTask("A");
- assertThat(executionTaskA).isNull();
+ }
+
+ @Test
+ public void testCheckServiceOrderDeleteRejected() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.getService().setId("no_response");
+
+ }
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("106");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.id");
+ }
+ }
+
+ @Test
+ public void testCheckServiceOrderNoChange() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.setAction(ActionType.NOCHANGE);
+ }
+
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+ }
+
+ }
+
+
+
+ @Test
+ public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ serviceOrderItem.setAction(ActionType.NOCHANGE);
+ }
+ serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+ }
+
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A"))
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+ }
+ }
+
+
+ @Test
+ public void testCheckServiceOrderDeleteWithKoServiceSpecId() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.getService().getServiceSpecification().setId("undefined");
+ }
+
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A"))
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.REJECTED);
+ }
+ }
+
+
+
+
+ @Test
+ public void testCheckServiceOrderRejected() throws Exception {
+
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+ serviceOrderResource.scheduleCheckServiceOrders();
+
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
+
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if(serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("102");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("serviceSpecification.id");
+ }
+ }
+ }
+
+ @Test
+ public void validateServiceOrderBeanWithAnnotation() {
+ ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ Set violations = validator.validate(serviceOrder);
+ assertThat(violations).isEmpty();
+
+ ServiceOrderItem item = new ServiceOrderItem();
+ item.setAction(ActionType.DELETE);
+ item.setService(new Service());
+ serviceOrder.addOrderItemItem(item);
+
+ violations = validator.validate(serviceOrder);
+ assertThat(violations).isNotEmpty();
+
+ ServiceOrder serviceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ serviceOrder2.getOrderItem().get(0).getService().getServiceSpecification().setId("");
+ serviceOrder2.getOrderItem().get(1).getService().getServiceSpecification().setId(" ");
+
+ violations = validator.validate(serviceOrder2);
+ assertThat(violations).isNotEmpty();
+ assertThat(violations.size()).isEqualTo(2);
+
+ }
+
+
+
+ @Test
+ public void testFindAndGetServiceOrder() throws Exception {
+
+ ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+ serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+ }
+ testServiceOrder.setExternalId("extid1");
+ testServiceOrder.setOrderDate(new Date());
+ testServiceOrder.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder.setDescription("toto");
+ testServiceOrder.setId("test");
+ serviceOrderRepository.save(testServiceOrder);
+
+
+ ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
+ testServiceOrder2.setState(StateType.ACKNOWLEDGED);
+ testServiceOrder2.setDescription("toto");
+ testServiceOrder2.setId("test2");
+ testServiceOrder2.setExternalId("extid2");
+ testServiceOrder2.setOrderDate(new Date());
+
+ serviceOrderRepository.save(testServiceOrder2);
+
+
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("fields", "id");
+
+ ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
+ ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
+ assertThat(serviceOrders.size()).isEqualTo(2);
+
+ params.add("externalId", "extid1");
+ params.add("state", "acknowledged");
+
+ serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
+ serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
+ assertThat(serviceOrders.size()).isEqualTo(1);
+
+ MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
+ paramsDate.add("orderDate.gt", "2017-01-01T00:00:00.000Z");
+ paramsDate.add("orderDate.lt", "2030-01-01T00:00:00.000Z");
+ paramsDate.add("offset", "0");
+ paramsDate.add("limit", "2");
+
+ serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
+ serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
+ assertThat(serviceOrders.size()).isEqualTo(2);
+
+
+ ResponseEntity<Object> serviceOrderResponse =
+ serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
+ ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
+ assertThat(serviceOrder).isNotNull();
+ }
+
+
+
+ @Test
+ public void testExecutionTaskSuccess() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+ ExecutionTask executionTaskB;
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+ } else {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ }
+ }
+
+ executionTaskB = getExecutionTask("B");
+ assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+ executionTaskA = getExecutionTask("A");
+ assertThat(executionTaskA).isNull();
SoTaskProcessor.processOrderItem(executionTaskB);
serviceOrderChecked = serviceOrderRepository.findOne("test");
}
- executionTaskB = getExecutionTask("B");
- assertThat(executionTaskB).isNull();
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
}
+ @Test
+ public void testE2EExecutionTaskSuccess() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+ ExecutionTask executionTaskB;
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+ } else {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ }
+ }
+
+ executionTaskB = getExecutionTask("B");
+ assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+ executionTaskA = getExecutionTask("A");
+ assertThat(executionTaskA).isNull();
+
+ SoTaskProcessor.processOrderItem(executionTaskB);
+ serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+
+
+ }
@Test
public void testExecutionTaskDeleteSuccess() throws Exception {
ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
- serviceOrderInfoRepository, executionTaskRepository, ActionType.DELETE);
+ executionTaskRepository, ActionType.DELETE);
ExecutionTask executionTaskB;
}
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+
+
+ }
+
+ @Test
+ public void testE2EExecutionTaskDeleteSuccess() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.DELETE);
+ ExecutionTask executionTaskB;
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+ } else {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ }
+ }
+
executionTaskB = getExecutionTask("B");
- assertThat(executionTaskB).isNull();
+ assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+ executionTaskA = getExecutionTask("A");
+ assertThat(executionTaskA).isNull();
+
+ SoTaskProcessor.processOrderItem(executionTaskB);
+ serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
}
public void testExecutionTaskFailed() throws Exception {
ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
- serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
+ executionTaskRepository, ActionType.ADD);
- ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
- StubMapping mappingToDelete = null;
- List<StubMapping> mappings = listStubMappingsResult.getMappings();
- for (StubMapping mapping : mappings) {
- if (mapping.getRequest().getUrl().equals("/ecomp/mso/infra/orchestrationRequests/v4/requestId")) {
- mappingToDelete = mapping;
+ removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
+ } else {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
}
}
- wireMockServer.removeStubMapping(mappingToDelete);
+ executionTaskA = getExecutionTask("A");
+ Date createDate = executionTaskA.getCreateDate();
+ assertThat(executionTaskA.getLastAttemptDate().getTime()> createDate.getTime()).isTrue();
+
+ changeCreationDate(executionTaskA);
+ SoTaskProcessor.processOrderItem(executionTaskA);
+
+ serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+
+ }
+
+ private void changeCreationDate(ExecutionTask executionTaskA) {
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(executionTaskA.getCreateDate());
+ cal.add(Calendar.SECOND, -30);
+ executionTaskA.setCreateDate(cal.getTime());
+ }
+
+
+ @Test
+ public void testE2EExecutionTaskFailed() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+
+ removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
SoTaskProcessor.processOrderItem(executionTaskA);
}
}
executionTaskA = getExecutionTask("A");
- assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
+ assertThat(executionTaskA.getLastAttemptDate().getTime()>executionTaskA.getCreateDate().getTime()).isTrue();
+ changeCreationDate(executionTaskA);
+ SoTaskProcessor.processOrderItem(executionTaskA);
+
+ serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+
+ }
+
+ @Test
+ public void testExecutionTaskFailedNoSoResponse() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+
+ removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+
+
+ }
+
+ @Test
+ public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+
+ removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
+ removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+ }
+
+ @Test
+ public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForE2EExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+
+ removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3");
+ removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
+
+
SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+ }
+
+
+ @Test
+ public void testExecutionTaskFailedBadRequestSo() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.ADD);
+
+
+ changeWireMockResponse("/onap/so/infra/serviceInstantiation/v7/serviceInstances/",400,"\"serviceException\": {\n"
+ + " \"messageId\": \"SVC0002\",\n"
+ + " \"text\": \"Error parsing request. org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
+ + " }");
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if(serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
+ assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.name");
+ }
+ }
+
+ }
+
+
+ @Test
+ public void testExecutionTaskModifySuccess() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.MODIFY);
+ ExecutionTask executionTaskB;
+
+
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ //assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE);
+ } else {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ }
+ }
+ SoTaskProcessor.processOrderItem(executionTaskA);
+ serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+ } else {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ }
+ }
+
+ executionTaskB = getExecutionTask("B");
+ assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
executionTaskA = getExecutionTask("A");
+ assertThat(executionTaskA).isNull();
+
+ SoTaskProcessor.processOrderItem(executionTaskB);
+ SoTaskProcessor.processOrderItem(executionTaskB);
+
+ serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+
+ }
+
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+ }
+
+
+
+
+ @Test
+ public void testExecutionTaskModifyFailed() throws Exception {
+
+ ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
+ executionTaskRepository, ActionType.MODIFY);
+ ExecutionTask executionTaskB;
+ removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
+
+
SoTaskProcessor.processOrderItem(executionTaskA);
+ ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
+ assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+ for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+ if (serviceOrderItem.getId().equals("A")) {
+ //assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_REQUEST_DELETE_SEND);
+ } else {
+ assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+ }
+ }
executionTaskA = getExecutionTask("A");
+ assertThat(executionTaskA.getLastAttemptDate().getTime()>executionTaskA.getCreateDate().getTime()).isTrue();
+ changeCreationDate(executionTaskA);
SoTaskProcessor.processOrderItem(executionTaskA);
serviceOrderChecked = serviceOrderRepository.findOne("test");
}
- ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
- assertThat(executionTaskB).isNull();
+ assertThat(executionTaskRepository.count()).isEqualTo(0);
+
+ }
+
+ // hub
+
+ @Test
+ public void testFindWhenNoSubscriber() throws Exception {
+ ResponseEntity<Object> findResponseEntity = hubResource.findSubscribers(new LinkedMultiValueMap<>());
+ assertThat(findResponseEntity.getStatusCodeValue()).isEqualTo(200);
+ ArrayList subscribers = (ArrayList) findResponseEntity.getBody();
+ assertThat(subscribers.size()).isEqualTo(0);
+ }
+
+ @Test
+ public void testSubscriberCreation() throws Exception {
+ ResponseEntity<Subscriber> firstCreationResponseEntity = hubResource
+ .createEventSubscription(HubAssertions.createServiceOrderCreationSubscription());
+ assertThat(firstCreationResponseEntity.getStatusCodeValue()).isEqualTo(201);
+ assertThat(firstCreationResponseEntity.getHeaders().getLocation()).isNotNull();
+ assertThat(subscriptionService.countSubscription()).isEqualTo(1);
+ }
+
+ @Test
+ public void testCreationAndFindSubscriber() throws Exception {
+ ResponseEntity<Subscriber> firstCreationResponseEntity = hubResource
+ .createEventSubscription(HubAssertions.createServiceOrderCreationSubscription());
+ ResponseEntity<Object> findResponseEntity = hubResource.findSubscribers(new LinkedMultiValueMap<>());
+ ArrayList subscribers = (ArrayList) findResponseEntity.getBody();
+ assertThat(subscribers.size()).isEqualTo(1);
+ }
+ @Test
+ public void testCreationAndGetByIdSubscriber() throws Exception {
+ ResponseEntity<Subscriber> createResponseEntity = hubResource
+ .createEventSubscription(HubAssertions.createServiceOrderCreationSubscription());
+ String resourceId = createResponseEntity.getHeaders().getLocation().getPath().substring(1);
+ ResponseEntity<Subscription> getResponseEntity = hubResource.getSubscription(resourceId);
+ assertThat(getResponseEntity.getStatusCodeValue()).isEqualTo(200);
+ assertThat(getResponseEntity.getBody()).isInstanceOf(Subscription.class);
+ }
+ @Test
+ public void testMultiCreationAndFindSubscriber() throws Exception {
+ hubResource.createEventSubscription(HubAssertions.createServiceOrderCreationSubscription());
+ hubResource.createEventSubscription(HubAssertions.createServiceOrderStateChangeSubscription());
+ hubResource.createEventSubscription(HubAssertions.createServiceOrderItemStateChangeSubscription());
+
+ ResponseEntity<Object> findAllResponseEntity = hubResource.findSubscribers(new LinkedMultiValueMap<>());
+ ArrayList subscribers = (ArrayList) findAllResponseEntity.getBody();
+ assertThat(subscribers.size()).isEqualTo(3);
}
+ @Test
+ public void testMultiCreationAndFindWithFilteringSubscriber() throws Exception {
+ hubResource.createEventSubscription(HubAssertions.createServiceOrderCreationSubscription());
+ hubResource.createEventSubscription(HubAssertions.createServiceOrderStateChangeSubscription());
+ hubResource.createEventSubscription(HubAssertions.createServiceOrderItemStateChangeSubscription());
+
+ MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+ params.add("query.eventType", "ServiceOrderCreationNotification");
+ ResponseEntity<Object> findWithFilterResponseEntity = hubResource.findSubscribers(params);
+ ArrayList subscribers = (ArrayList) findWithFilterResponseEntity.getBody();
+ assertThat(subscribers.size()).isEqualTo(1);
+ }
+
+ @Test
+ public void testSubscriberDeletion() throws Exception {
+ ResponseEntity<Subscriber> createResponseEntity = hubResource
+ .createEventSubscription(HubAssertions.createServiceOrderCreationSubscription());
+ String resourceId = createResponseEntity.getHeaders().getLocation().getPath().substring(1);
+
+ ResponseEntity<Object> findResponseEntity = hubResource.findSubscribers(new LinkedMultiValueMap<>());
+ ArrayList subscribers = (ArrayList) findResponseEntity.getBody();
+ assertThat(subscribers.size()).isEqualTo(1);
+
+ hubResource.deleteSubscription(resourceId);
+
+ findResponseEntity = hubResource.findSubscribers(new LinkedMultiValueMap<>());
+ subscribers = (ArrayList) findResponseEntity.getBody();
+ assertThat(subscribers).isEmpty();
+ }
}
Code Review / externalapi / nbi.git / blobdiff