dcaedt_be/src/test/java/org/onap/sdc/dcae/services/GetServicesTest.java

   1 package org.onap.sdc.dcae.services;
   2
   3 import static org.assertj.core.api.Assertions.assertThat;
   4
   5 import java.util.ArrayList;
   6 import java.util.Arrays;
   7 import java.util.LinkedHashMap;
   8 import java.util.List;
   9 import java.util.UUID;
  10 import java.util.stream.Collectors;
  11
  12 import org.onap.sdc.dcae.composition.restmodels.DcaeMinimizedService;
  13 import org.onap.sdc.dcae.composition.controller.ServicesController;
  14 import org.onap.sdc.dcae.composition.util.DcaeBeConstants;
  15 import org.onap.sdc.dcae.composition.util.DcaeBeConstants.LifecycleStateEnum;
  16 import org.testng.annotations.Test;
  17
  18 public class GetServicesTest {
  19
  20
  21         @Test
  22         public void parseAndFliterServicesByUser_nullServices_TBD() {
  23 //              fail("TODO Auto-generated method stub");
  24         }
  25
  26
  27         @Test
  28         public void parseAndFliterServicesByUser_emptyList_emptyList() {
  29                 // arrange
  30                 ServicesController target = new ServicesController();
  31                 String user_id = "test";
  32                 String lastUpdaterUserId = "test";
  33                 List<LinkedHashMap<String, String>> services = new ArrayList<LinkedHashMap<String, String>>();
  34                 // act
  35                 List<DcaeMinimizedService> result = target.parseAndFilterServicesByUser(lastUpdaterUserId, services, user_id);
  36                 // assert
  37                 assertThat(result).isEqualTo(new ArrayList<DcaeMinimizedService>());
  38         }
  39
  40
  41         @Test
  42         public void parseAndFliterServicesByUser_singleServicesAsMap_singleServiceParsed() {
  43                 // arrange
  44                 String user_id = "test";
  45                 String lastUpdaterUserId = user_id;
  46                 String uuid = "a";
  47                 String invariantUUID = "1";
  48                 String lifecycleState = LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name();
  49                 String version = "0.1";
  50                 String serviceName = "TestService";
  51
  52                 ServicesController target = new ServicesController();
  53                 LinkedHashMap<String, String> service = createServiceAsMap(lastUpdaterUserId, uuid, invariantUUID,
  54                                 lifecycleState, version, serviceName);
  55                 List<LinkedHashMap<String, String>> services = new ArrayList<LinkedHashMap<String, String>>(
  56                                 Arrays.asList(service));
  57
  58                 DcaeMinimizedService expected = new DcaeMinimizedService(uuid, serviceName, lastUpdaterUserId, lifecycleState,
  59                                 version, invariantUUID);
  60                 // act
  61                 List<DcaeMinimizedService> result = target.parseAndFilterServicesByUser(lastUpdaterUserId, services, user_id);
  62                 // assert
  63                 assertThat(result).usingRecursiveFieldByFieldElementComparator().contains(expected);
  64         }
  65
  66
  67         @Test
  68         public void parseAndFliterServicesByUser_unsortedServices_sortedServices() {
  69                 // arrange
  70                 String user_id = "test";
  71                 String lastUpdaterUserId = user_id;
  72                 String uuid = "a";
  73                 String lifecycleState = LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name();
  74                 String version = "0.1";
  75
  76                 List<LinkedHashMap<String, String>> unsortedServices = Arrays.asList("d", "a", "c", "b").stream()
  77                                 .map(x -> createServiceAsMap(lastUpdaterUserId, uuid, UUID.randomUUID().toString(), lifecycleState, version, x))
  78                                 .collect(Collectors.toList());
  79
  80                 ServicesController target = new ServicesController();
  81
  82                 // act
  83                 List<DcaeMinimizedService> result = target.parseAndFilterServicesByUser(lastUpdaterUserId, unsortedServices,
  84                                 user_id);
  85                 // assert
  86                 assertThat(result).extracting("name").containsExactly("a","b","c","d");
  87         }
  88
  89
  90         @Test
  91         public void parseAndFliterServicesByUser_allOptionsForLastUpdaterAndIsCheckout_allOptionsButIsCheckoutAndNotLastUpdater() {
  92                 // ------------user == last_updater
  93                 // -----------------True----False--
  94                 // isCheckout----------------------
  95                 // --------True------V--------X----
  96                 // --------False-----V--------V----
  97                 // --------------------------------
  98 //              fail("TODO Auto-generated method stub");
  99         }
 100
 101
 102         @Test
 103         public void parseAndFliterServicesByUser_singleServiceWithMultiVersions_singleServiceWithLatestVersion() {
 104                 // arrange
 105                 String user_id = "test";
 106                 String lastUpdaterUserId = user_id;
 107                 String uuid = "a";
 108                 String invariantUUID = "1";
 109                 String lifecycleState = LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name();
 110                 String serviceName = "TestService";
 111
 112                 List<LinkedHashMap<String, String>> singleServiceWithMultiVersions = Arrays.asList("1.0", "0.3", "11.0", "2.0", "1.8").stream()
 113                                 .map(x -> createServiceAsMap(lastUpdaterUserId, uuid, invariantUUID, lifecycleState, x, serviceName))
 114                                 .collect(Collectors.toList());
 115
 116                 ServicesController target = new ServicesController();
 117
 118                 // act
 119                 List<DcaeMinimizedService> result = target.parseAndFilterServicesByUser(lastUpdaterUserId, singleServiceWithMultiVersions, user_id);
 120
 121                 // assert
 122                 assertThat(result).extracting("version").containsExactly("11.0");
 123         }
 124
 125
 126         private static LinkedHashMap<String, String> createServiceAsMap(String lastUpdaterUserId, String uuid,
 127                         String invariantUUID, String lifecycleState, String version, String serviceName) {
 128
 129                 LinkedHashMap<String, String> service = new LinkedHashMap<String, String>() {
 130                         {
 131                                 put("invariantUUID", invariantUUID);
 132                                 put("uuid", uuid);
 133                                 put("name", serviceName);
 134                                 put("lastUpdaterUserId", lastUpdaterUserId);
 135                                 put("lifecycleState", lifecycleState);
 136                                 put("version", version);
 137                         }
 138                 };
 139
 140                 return service;
 141         }
 142
 143 }