Add Apache license header per file
[externalapi/nbi.git] / src / test / java / org / onap / nbi / apis / ApiTest.java
1 /**
2  *
3  *     Copyright (c) 2017 Orange.  All rights reserved.
4  *
5  *     Licensed under the Apache License, Version 2.0 (the "License");
6  *     you may not use this file except in compliance with the License.
7  *     You may obtain a copy of the License at
8  *
9  *         http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *     Unless required by applicable law or agreed to in writing, software
12  *     distributed under the License is distributed on an "AS IS" BASIS,
13  *     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *     See the License for the specific language governing permissions and
15  *     limitations under the License.
16  */
17 package org.onap.nbi.apis;
18
19
20 import static org.assertj.core.api.Assertions.assertThat;
21 import java.util.ArrayList;
22 import java.util.Date;
23 import java.util.List;
24 import java.util.Set;
25 import javax.validation.Validation;
26 import javax.validation.Validator;
27 import javax.validation.ValidatorFactory;
28 import org.junit.After;
29 import org.junit.AfterClass;
30 import org.junit.BeforeClass;
31 import org.junit.Ignore;
32 import org.junit.Test;
33 import org.junit.runner.RunWith;
34 import org.onap.nbi.apis.assertions.ServiceCatalogAssertions;
35 import org.onap.nbi.apis.assertions.ServiceInventoryAssertions;
36 import org.onap.nbi.apis.assertions.ServiceOrderAssertions;
37 import org.onap.nbi.apis.servicecatalog.ServiceSpecificationResource;
38 import org.onap.nbi.apis.serviceinventory.ServiceInventoryResource;
39 import org.onap.nbi.apis.serviceorder.ServiceOrderResource;
40 import org.onap.nbi.apis.serviceorder.model.ActionType;
41 import org.onap.nbi.apis.serviceorder.model.RelatedParty;
42 import org.onap.nbi.apis.serviceorder.model.Service;
43 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
44 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
45 import org.onap.nbi.apis.serviceorder.model.StateType;
46 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
47 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
48 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderInfoRepository;
49 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
50 import org.onap.nbi.apis.serviceorder.workflow.SOTaskProcessor;
51 import org.springframework.beans.factory.annotation.Autowired;
52 import org.springframework.boot.context.embedded.LocalServerPort;
53 import org.springframework.boot.test.context.SpringBootTest;
54 import org.springframework.http.ResponseEntity;
55 import org.springframework.test.context.junit4.SpringRunner;
56 import org.springframework.util.LinkedMultiValueMap;
57 import org.springframework.util.MultiValueMap;
58 import com.github.tomakehurst.wiremock.WireMockServer;
59 import com.github.tomakehurst.wiremock.stubbing.ListStubMappingsResult;
60 import com.github.tomakehurst.wiremock.stubbing.StubMapping;
61
62 @RunWith(SpringRunner.class)
63 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
64 public class ApiTest {
65
66     @LocalServerPort
67     int randomServerPort;
68
69     String realServerPort;
70
71     static public WireMockServer wireMockServer = new WireMockServer(8091);
72
73     @Autowired
74     ServiceSpecificationResource serviceSpecificationResource;
75
76     @Autowired
77     ServiceInventoryResource serviceInventoryResource;
78
79     @Autowired
80     ServiceOrderResource serviceOrderResource;
81
82     @Autowired
83     ServiceOrderRepository serviceOrderRepository;
84
85     @Autowired
86     ServiceOrderInfoRepository serviceOrderInfoRepository;
87
88     @Autowired
89     ExecutionTaskRepository executionTaskRepository;
90
91     @Autowired
92     SOTaskProcessor SoTaskProcessor;
93
94     static Validator validator;
95
96     @BeforeClass
97     public static void setUp() throws Exception {
98         wireMockServer.start();
99         ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
100         validator = factory.getValidator();
101     }
102
103     @AfterClass
104     public static void tearsDown() throws Exception {
105         wireMockServer.stop();
106
107     }
108
109     @After
110     public void tearsDownUpPort() throws Exception {
111         executionTaskRepository.deleteAll();
112         serviceOrderInfoRepository.deleteAll();
113         serviceOrderRepository.deleteAll();
114         wireMockServer.resetToDefaultMappings();
115
116     }
117
118
119     public ExecutionTask getExecutionTask(String orderItemId) {
120         for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
121             if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
122                 return executionTask;
123             }
124
125         }
126         return null;
127     }
128
129     // serviceCatalog
130
131     @Test
132     @Ignore
133     public void testServiceResourceGetCatalog() throws Exception {
134
135         ResponseEntity<Object> resource =
136                 serviceSpecificationResource.getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439", null);
137         ServiceCatalogAssertions.assertGetServiceCatalog(resource);
138
139     }
140
141     @Test
142     public void testServiceCatalogGetResourceWithoutTosca() throws Exception {
143
144         ResponseEntity<Object> resource = serviceSpecificationResource
145                 .getServiceSpecification("1e3feeb0-8e36-46c6-862c-236d9c626439_withoutTosca", null);
146         ServiceCatalogAssertions.asserGetServiceCatalogWithoutTosca(resource);
147
148     }
149
150     @Test
151     public void testServiceCatalogFind() throws Exception {
152
153         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(null);
154         ServiceCatalogAssertions.assertFindServiceCatalog(resource);
155
156     }
157
158
159     @Test
160     public void testServiceCatalogFindWithFilter() throws Exception {
161
162         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
163         params.add("fields", "name");
164         ResponseEntity<Object> resource = serviceSpecificationResource.findServiceSpecification(params);
165         ServiceCatalogAssertions.assertFindServiceCatalogWIthFilter(resource);
166
167     }
168
169     // serviceInventory
170
171     @Test
172     public void testServiceResourceGetInventory() throws Exception {
173
174         String serviceName = "vFW";
175         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
176         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
177         params.add("serviceSpecification.name", serviceName);
178         params.add("relatedParty.id", "6490");
179         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
180         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
181
182     }
183
184
185     @Test
186     public void testServiceResourceGetInventoryWithServiceSpecId() throws Exception {
187
188         String serviceId = "e4688e5f-61a0-4f8b-ae02-a2fbde623bcb";
189         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
190         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
191         params.add("relatedParty.id", "6490");
192         ResponseEntity<Object> resource = serviceInventoryResource.getServiceInventory(serviceId, params);
193         ServiceInventoryAssertions.assertServiceInventoryGet(resource);
194
195     }
196
197
198     @Test
199     public void testServiceInventoryFind() throws Exception {
200
201         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
202         String serviceName = "vFW";
203         params.add("serviceSpecification.name", serviceName);
204         params.add("relatedParty.id", "6490");
205
206         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
207         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
208
209     }
210
211
212     @Test
213     public void testServiceInventoryFindWithServiceSpecId() throws Exception {
214
215         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
216         params.add("serviceSpecification.id", "1e3feeb0-8e36-46c6-862c-236d9c626439");
217         params.add("relatedParty.id", "6490");
218
219         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
220         ServiceInventoryAssertions.assertServiceInventoryFind(resource);
221
222     }
223
224
225     @Test
226     public void testServiceInventoryFindWithoutParameter() throws Exception {
227
228         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
229         params.add("relatedParty.id", "6490");
230
231         ResponseEntity<Object> resource = serviceInventoryResource.findServiceInventory(params);
232         ServiceInventoryAssertions.assertServiceInventoryFindWithoutParameter(resource);
233
234     }
235
236     @Test
237     public void testCreateServiceOrderResource() throws Exception {
238
239         ResponseEntity<Object> serviceOrder = serviceOrderResource
240                 .createServiceOrder(ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD), null, null);
241         assertThat(serviceOrder.getStatusCodeValue()).isEqualTo(201);
242         ServiceOrder body = (ServiceOrder) serviceOrder.getBody();
243         assertThat(body.getId()).isNotNull();
244         assertThat(body.getState()).isEqualTo(StateType.ACKNOWLEDGED);
245
246
247     }
248
249     @Test
250     public void testCheckServiceOrder() throws Exception {
251
252         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
253         testServiceOrder.setState(StateType.ACKNOWLEDGED);
254         testServiceOrder.setId("test");
255         serviceOrderRepository.save(testServiceOrder);
256
257         serviceOrderResource.scheduleCheckServiceOrders();
258
259         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
260         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
261
262     }
263
264     @Test
265     public void testCheckServiceOrderWithGenericCustomer() throws Exception {
266
267         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
268         testServiceOrder.setRelatedParty(new ArrayList<>());
269         testServiceOrder.setState(StateType.ACKNOWLEDGED);
270         testServiceOrder.setId("test");
271         serviceOrderRepository.save(testServiceOrder);
272
273         serviceOrderResource.scheduleCheckServiceOrders();
274
275         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
276         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
277
278     }
279
280     @Test
281     public void testCheckServiceOrderWithUnKnonwCustomer() throws Exception {
282
283         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
284         List<RelatedParty> customers = new ArrayList<>();
285         RelatedParty customer = new RelatedParty();
286         customer.setId("new");
287         customer.setRole("ONAPcustomer");
288         customer.setName("romain");
289         customers.add(customer);
290         testServiceOrder.setRelatedParty(customers);
291         testServiceOrder.setState(StateType.ACKNOWLEDGED);
292         testServiceOrder.setId("test");
293         serviceOrderRepository.save(testServiceOrder);
294
295         serviceOrderResource.scheduleCheckServiceOrders();
296
297         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
298         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
299
300     }
301
302     @Test
303     public void testCheckServiceOrderDelete() throws Exception {
304
305         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
306         testServiceOrder.setState(StateType.ACKNOWLEDGED);
307         testServiceOrder.setId("test");
308         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
309             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
310         }
311         serviceOrderRepository.save(testServiceOrder);
312
313         serviceOrderResource.scheduleCheckServiceOrders();
314
315         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
316         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
317
318     }
319
320     @Test
321     public void testCheckServiceOrderDeleteRejected() throws Exception {
322
323         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
324         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
325             serviceOrderItem.getService().setId("no_response");
326
327         }
328         testServiceOrder.setState(StateType.ACKNOWLEDGED);
329         testServiceOrder.setId("test");
330         serviceOrderRepository.save(testServiceOrder);
331
332         serviceOrderResource.scheduleCheckServiceOrders();
333
334         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
335         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
336
337     }
338
339     @Test
340     public void testCheckServiceOrderNoChange() throws Exception {
341
342         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
343         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
344             serviceOrderItem.setAction(ActionType.NOCHANGE);
345         }
346
347         testServiceOrder.setState(StateType.ACKNOWLEDGED);
348         testServiceOrder.setId("test");
349         serviceOrderRepository.save(testServiceOrder);
350
351         serviceOrderResource.scheduleCheckServiceOrders();
352
353         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
354         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
355         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
356             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
357         }
358
359     }
360
361
362
363     @Test
364     public void testCheckServiceOrderNoChangeAndDelete() throws Exception {
365
366         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.DELETE);
367         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
368             if (serviceOrderItem.getId().equals("A")) {
369                 serviceOrderItem.setAction(ActionType.NOCHANGE);
370             }
371             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
372         }
373
374         testServiceOrder.setState(StateType.ACKNOWLEDGED);
375         testServiceOrder.setId("test");
376         serviceOrderRepository.save(testServiceOrder);
377
378         serviceOrderResource.scheduleCheckServiceOrders();
379
380         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
381         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.ACKNOWLEDGED);
382         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
383             if (serviceOrderItem.getId().equals("A"))
384                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
385         }
386     }
387
388
389
390     @Test
391     public void testCheckServiceOrderRejected() throws Exception {
392
393
394         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrderRejected();
395         testServiceOrder.setState(StateType.ACKNOWLEDGED);
396         testServiceOrder.setId("test");
397         serviceOrderRepository.save(testServiceOrder);
398
399         serviceOrderResource.scheduleCheckServiceOrders();
400
401         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
402         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.REJECTED);
403
404     }
405
406     @Test
407     public void validateServiceOrderBeanWithAnnotation() {
408         ServiceOrder serviceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
409         Set violations = validator.validate(serviceOrder);
410         assertThat(violations).isEmpty();
411
412         ServiceOrderItem item = new ServiceOrderItem();
413         item.setAction(ActionType.DELETE);
414         item.setService(new Service());
415         serviceOrder.addOrderItemItem(item);
416
417         violations = validator.validate(serviceOrder);
418         assertThat(violations).isNotEmpty();
419     }
420
421
422
423     @Test
424     public void testFindAndGetServiceOrder() throws Exception {
425
426         ServiceOrder testServiceOrder = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
427         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
428             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
429         }
430         testServiceOrder.setExternalId("extid1");
431         testServiceOrder.setOrderDate(new Date());
432         testServiceOrder.setState(StateType.ACKNOWLEDGED);
433         testServiceOrder.setDescription("toto");
434         testServiceOrder.setId("test");
435         serviceOrderRepository.save(testServiceOrder);
436
437
438         ServiceOrder testServiceOrder2 = ServiceOrderAssertions.createTestServiceOrder(ActionType.ADD);
439         testServiceOrder2.setState(StateType.ACKNOWLEDGED);
440         testServiceOrder2.setDescription("toto");
441         testServiceOrder2.setId("test2");
442         testServiceOrder2.setExternalId("extid2");
443         testServiceOrder2.setOrderDate(new Date());
444
445         serviceOrderRepository.save(testServiceOrder2);
446
447
448         MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
449         params.add("fields", "id");
450
451         ResponseEntity<Object> serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
452         ArrayList serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
453         assertThat(serviceOrders.size()).isEqualTo(2);
454
455         params.add("externalId", "extid1");
456         params.add("state", "acknowledged");
457
458         serviceOrdersResponse = serviceOrderResource.findServiceOrder(params);
459         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
460         assertThat(serviceOrders.size()).isEqualTo(1);
461
462         MultiValueMap<String, String> paramsDate = new LinkedMultiValueMap<>();
463         paramsDate.add("orderDate.gt", "2017-01-01 00:00:00.000");
464         paramsDate.add("orderDate.lt", "2030-01-01 00:00:00.000");
465         paramsDate.add("offset", "0");
466         paramsDate.add("limit", "2");
467
468         serviceOrdersResponse = serviceOrderResource.findServiceOrder(paramsDate);
469         serviceOrders = (ArrayList) serviceOrdersResponse.getBody();
470         assertThat(serviceOrders.size()).isEqualTo(2);
471
472
473         ResponseEntity<Object> serviceOrderResponse =
474                 serviceOrderResource.getServiceOrder("test2", new LinkedMultiValueMap<>());
475         ServiceOrder serviceOrder = (ServiceOrder) serviceOrderResponse.getBody();
476         assertThat(serviceOrder).isNotNull();
477     }
478
479
480
481     @Test
482     public void testExecutionTaskSuccess() throws Exception {
483
484         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
485                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
486         ExecutionTask executionTaskB;
487
488
489         SoTaskProcessor.processOrderItem(executionTaskA);
490         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
491         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
492         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
493             if (serviceOrderItem.getId().equals("A")) {
494                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
495             } else {
496                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
497             }
498         }
499
500         executionTaskB = getExecutionTask("B");
501         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
502         executionTaskA = getExecutionTask("A");
503         assertThat(executionTaskA).isNull();
504
505         SoTaskProcessor.processOrderItem(executionTaskB);
506         serviceOrderChecked = serviceOrderRepository.findOne("test");
507         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
508         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
509             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
510
511         }
512
513         executionTaskB = getExecutionTask("B");
514         assertThat(executionTaskB).isNull();
515
516
517     }
518
519
520     @Test
521     public void testExecutionTaskDeleteSuccess() throws Exception {
522
523         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
524                 serviceOrderInfoRepository, executionTaskRepository, ActionType.DELETE);
525         ExecutionTask executionTaskB;
526
527
528         SoTaskProcessor.processOrderItem(executionTaskA);
529         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
530         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
531         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
532             if (serviceOrderItem.getId().equals("A")) {
533                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
534             } else {
535                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
536             }
537         }
538
539         executionTaskB = getExecutionTask("B");
540         assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
541         executionTaskA = getExecutionTask("A");
542         assertThat(executionTaskA).isNull();
543
544         SoTaskProcessor.processOrderItem(executionTaskB);
545         serviceOrderChecked = serviceOrderRepository.findOne("test");
546         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
547         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
548             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
549
550         }
551
552         executionTaskB = getExecutionTask("B");
553         assertThat(executionTaskB).isNull();
554
555
556     }
557
558
559     @Test
560     public void testExecutionTaskFailed() throws Exception {
561
562         ExecutionTask executionTaskA = ServiceOrderAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
563                 serviceOrderInfoRepository, executionTaskRepository, ActionType.ADD);
564
565         ListStubMappingsResult listStubMappingsResult = wireMockServer.listAllStubMappings();
566         StubMapping mappingToDelete = null;
567         List<StubMapping> mappings = listStubMappingsResult.getMappings();
568         for (StubMapping mapping : mappings) {
569             if (mapping.getRequest().getUrl().equals("/ecomp/mso/infra/orchestrationRequests/v4/requestId")) {
570                 mappingToDelete = mapping;
571             }
572         }
573         wireMockServer.removeStubMapping(mappingToDelete);
574
575
576         SoTaskProcessor.processOrderItem(executionTaskA);
577         ServiceOrder serviceOrderChecked = serviceOrderRepository.findOne("test");
578         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
579         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
580             if (serviceOrderItem.getId().equals("A")) {
581                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
582             } else {
583                 assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
584             }
585         }
586         executionTaskA = getExecutionTask("A");
587         assertThat(executionTaskA.getNbRetries()).isEqualTo(2);
588         SoTaskProcessor.processOrderItem(executionTaskA);
589         executionTaskA = getExecutionTask("A");
590         SoTaskProcessor.processOrderItem(executionTaskA);
591         executionTaskA = getExecutionTask("A");
592         SoTaskProcessor.processOrderItem(executionTaskA);
593
594         serviceOrderChecked = serviceOrderRepository.findOne("test");
595         assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
596         for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
597             assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
598
599         }
600
601         ExecutionTask executionTaskB = executionTaskRepository.findOne(Long.parseLong("2"));
602         assertThat(executionTaskB).isNull();
603
604
605     }
606
607 }