services/activity-spec/activity-spec-web/activity-spec-service/src/test/java/org/onap/sdc/activityspec/be/dao/impl/ActivitySpecZusammenDaoImplTest.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.sdc.activityspec.be.dao.impl;
  18
  19 import com.amdocs.zusammen.adaptor.inbound.api.types.item.*;
  20 import com.amdocs.zusammen.commons.health.data.HealthInfo;
  21 import com.amdocs.zusammen.datatypes.Id;
  22 import com.amdocs.zusammen.datatypes.SessionContext;
  23 import com.amdocs.zusammen.datatypes.item.*;
  24 import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
  25 import com.amdocs.zusammen.datatypes.itemversion.Tag;
  26 import org.onap.sdc.activityspec.be.dao.impl.ActivitySpecDaoZusammenImpl.InfoPropertyName;
  27 import org.onap.sdc.activityspec.be.dao.types.ActivitySpecEntity;
  28 import org.onap.sdc.activityspec.be.datatypes.ActivitySpecData;
  29 import org.onap.sdc.activityspec.be.datatypes.ActivitySpecParameter;
  30 import org.onap.sdc.activityspec.be.datatypes.ElementType;
  31 import org.openecomp.core.utilities.json.JsonUtil;
  32 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  33 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  34 import org.openecomp.sdc.versioning.dao.types.Version;
  35 import org.openecomp.types.ElementPropertyName;
  36 import org.testng.Assert;
  37 import org.testng.annotations.AfterMethod;
  38 import org.testng.annotations.BeforeMethod;
  39 import org.testng.annotations.Test;
  40
  41 import java.io.InputStream;
  42 import java.util.*;
  43 import java.util.stream.Collectors;
  44
  45 import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
  46
  47 public class ActivitySpecZusammenDaoImplTest {
  48
  49     private static final Version version = new Version();
  50     private static final String versionId = "1234";
  51     private static final String itemId = "5678";
  52     private static final String tenant = "dox";
  53
  54     private ZusammenAdaptorMock zusammenAdaptor;
  55     private ActivitySpecDaoZusammenImpl daoImpl;
  56     private ActivitySpecEntity entity;
  57
  58
  59     @BeforeMethod
  60     public void setUp() {
  61         SessionContextProviderFactory.getInstance().createInterface().create("test", tenant);
  62         zusammenAdaptor = new ZusammenAdaptorMock();
  63         daoImpl = new ActivitySpecDaoZusammenImpl(zusammenAdaptor);
  64         entity = new ActivitySpecEntity();
  65         entity = new ActivitySpecEntity();
  66
  67         entity.setId(itemId);
  68         version.setId(versionId);
  69         entity.setVersion(version);
  70         entity.setName("activitySpec");
  71         List<String> categoryList = new ArrayList<>();
  72         categoryList.add("category1");
  73         entity.setCategoryList(categoryList);
  74         ActivitySpecParameter inputParams = new ActivitySpecParameter("dbhost", "String");
  75         inputParams.setValue("localhost");
  76         List<ActivitySpecParameter> inputs = new ArrayList<>();
  77         inputs.add(inputParams);
  78         entity.setInputs(inputs);
  79     }
  80
  81     @AfterMethod
  82     public void tearDown() {
  83         SessionContextProviderFactory.getInstance().createInterface().close();
  84     }
  85
  86     @Test
  87     public void testCreate() {
  88         ItemVersion itemVersionmock = new ItemVersion();
  89         itemVersionmock.setId(new Id());
  90
  91         daoImpl.create(entity);
  92         SessionContext context = createSessionContext();
  93         ElementContext elementContext = new ElementContext(entity.getId(), entity.getVersion().getId());
  94         Optional<ElementInfo> testElementInfo =
  95                 zusammenAdaptor.getElementInfoByName(context, elementContext, Id.ZERO, ElementType.ACTIVITYSPEC.name());
  96         Assert.assertTrue(testElementInfo.isPresent());
  97         Assert.assertEquals(testElementInfo.get().getInfo().getName(), ElementType.ACTIVITYSPEC.name());
  98         Assert.assertEquals(testElementInfo.get().getInfo().getProperty(
  99                 ActivitySpecDaoZusammenImpl.InfoPropertyName.DESCRIPTION.getValue()), entity.getDescription());
 100         Assert.assertEquals(testElementInfo.get().getInfo().getProperty(InfoPropertyName.CATEGORY.getValue()),
 101                 entity.getCategoryList());
 102         Assert.assertEquals(testElementInfo.get().getInfo()
 103                                            .getProperty(ActivitySpecDaoZusammenImpl.InfoPropertyName.NAME.getValue()),
 104                 entity.getName());
 105
 106         final Optional<Element> testElement =
 107                 zusammenAdaptor.getElement(context, elementContext, zusammenAdaptor.elementId);
 108         final InputStream data = testElement.get().getData();
 109         final ActivitySpecData activitySpecData = JsonUtil.json2Object(data, ActivitySpecData.class);
 110         Assert.assertEquals(activitySpecData.getInputs().get(0).getName(), entity.getInputs().get(0).getName());
 111     }
 112
 113     @Test
 114     public void testGet() {
 115         final ActivitySpecEntity retrieved = daoImpl.get(entity);
 116         Assert.assertEquals(retrieved.getName(), entity.getName());
 117         Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
 118         Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
 119     }
 120
 121     @Test
 122     public void testUpdate() {
 123         entity.setDescription("Update AS version1");
 124         daoImpl.update(entity);
 125         final ActivitySpecEntity retrieved = daoImpl.get(entity);
 126         Assert.assertEquals(retrieved.getName(), entity.getName());
 127         Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
 128         Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
 129     }
 130
 131     private class ZusammenAdaptorMock implements ZusammenAdaptor {
 132
 133         private ItemVersion itemVersion;
 134         private final Map<String, Element> elementMap = new HashMap<>();
 135         String elementId;
 136
 137         @Override
 138         public Optional<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
 139
 140             return Optional.ofNullable(itemVersion);
 141         }
 142
 143         @Override
 144         public Collection<ItemVersion> listPublicVersions(SessionContext context, Id itemId) {
 145             return null;
 146         }
 147
 148         @Override
 149         public ItemVersion getPublicVersion(SessionContext context, Id itemId, Id versionId) {
 150             return null;
 151         }
 152
 153         @Override
 154         public Optional<Element> getElement(SessionContext context, ElementContext elementContext, String elementId) {
 155             return Optional.of(elementMap.get(elementId));
 156         }
 157
 158         @Override
 159         public Optional<Element> getElementByName(SessionContext context, ElementContext elementContext,
 160                                                          Id parentElementId, String elementName) {
 161             //return Optional.empty();
 162             ZusammenElement element = new ZusammenElement();
 163             Info info = new Info();
 164             element.setElementId(Id.ZERO);
 165             info.addProperty("name", entity.getName());
 166             info.addProperty("description", entity.getDescription());
 167             info.addProperty("category", entity.getCategoryList());
 168             element.setInfo(info);
 169             return Optional.ofNullable(element);
 170         }
 171
 172         @Override
 173         public Collection<ElementInfo> listElements(SessionContext context, ElementContext elementContext,
 174                                                            Id parentElementId) {
 175             return null;
 176         }
 177
 178         @Override
 179         public Collection<Element> listElementData(SessionContext context, ElementContext elementContext,
 180                                                           Id parentElementId) {
 181             return elementMap.values();
 182         }
 183
 184         @Override
 185         public Collection<ElementInfo> listElementsByName(SessionContext context, ElementContext elementContext,
 186                                                                  Id parentElementId, String elementName) {
 187
 188             return elementMap.values().stream()
 189                                                        .filter(element -> elementName.equals(element.getInfo()
 190                                                                                                    .getProperty(
 191                                                                                         ElementPropertyName.elementType
 192                                                                                         .name())))
 193                              .map(element -> {
 194                                  ElementInfo elementInfo = new ElementInfo();
 195                                  elementInfo.setId(element.getElementId());
 196                                  elementInfo.setInfo(element.getInfo());
 197                                  return elementInfo;
 198                              }).collect(Collectors.toList());
 199
 200         }
 201
 202         @Override
 203         public Optional<ElementInfo> getElementInfoByName(SessionContext context, ElementContext elementContext,
 204                                                                  Id parentElementId, String elementName) {
 205
 206
 207             return elementMap.values().stream()
 208                                                        .filter(element -> elementName.equals(element.getInfo()
 209                                                                                       .getProperty(
 210                                                                                         ElementPropertyName.elementType
 211                                                                                                            .name())))
 212                              .map(element -> {
 213                                  ElementInfo elementInfo = new ElementInfo();
 214                                  elementInfo.setId(element.getElementId());
 215                                  elementInfo.setInfo(element.getInfo());
 216                                  return elementInfo;
 217                              }).findAny();
 218
 219
 220         }
 221
 222         @Override
 223         public Element saveElement(SessionContext context, ElementContext elementContext, ZusammenElement element,
 224                                           String message) {
 225             if (element.getAction().equals(Action.CREATE) || element.getAction().equals(Action.UPDATE)) {
 226                 element.setElementId(new Id(UUID.randomUUID().toString()));
 227             }
 228             elementMap.put(element.getElementId().getValue(), element);
 229             elementId = element.getElementId().getValue();
 230             return element;
 231         }
 232
 233         @Override
 234         public void resolveElementConflict(SessionContext context, ElementContext elementContext,
 235                                                   ZusammenElement element, Resolution resolution) {
 236
 237         }
 238
 239         @Override
 240         public Collection<HealthInfo> checkHealth(SessionContext context) {
 241             return null;
 242         }
 243
 244         @Override
 245         public Id createItem(SessionContext context, Info info) {
 246             return null;
 247         }
 248
 249         @Override
 250         public void updateItem(SessionContext context, Id itemId, Info info) {
 251
 252         }
 253
 254         @Override
 255         public Id createVersion(SessionContext context, Id itemId, Id baseVersionId, ItemVersionData itemVersionData) {
 256             return null;
 257         }
 258
 259         @Override
 260         public void updateVersion(SessionContext context, Id itemId, Id versionId, ItemVersionData itemVersionData) {
 261
 262         }
 263
 264         @Override
 265         public ItemVersion getVersion(SessionContext context, Id itemId, Id versionId) {
 266             return null;
 267         }
 268
 269         @Override
 270         public String getVersion(SessionContext sessionContext) {
 271             return null;
 272         }
 273
 274         @Override
 275         public ItemVersionStatus getVersionStatus(SessionContext context, Id itemId, Id versionId) {
 276             return null;
 277         }
 278
 279         @Override
 280         public ItemVersionConflict getVersionConflict(SessionContext context, Id itemId, Id versionId) {
 281             return null;
 282         }
 283
 284         @Override
 285         public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 286
 287         }
 288
 289         @Override
 290         public void resetVersionHistory(SessionContext context, Id itemId, Id versionId, String changeRef) {
 291
 292         }
 293
 294
 295         @Override
 296         public void publishVersion(SessionContext context, Id itemId, Id versionId, String message) {
 297
 298         }
 299
 300         @Override
 301         public void syncVersion(SessionContext sessionContext, Id itemId, Id versionId) {
 302
 303         }
 304
 305         @Override
 306         public void forceSyncVersion(SessionContext context, Id itemId, Id versionId) {
 307
 308         }
 309
 310         @Override
 311         public void cleanVersion(SessionContext sessionContext, Id itemId, Id versionId) {
 312
 313         }
 314
 315         @Override
 316         public Optional<ElementInfo> getElementInfo(SessionContext context, ElementContext elementContext,
 317                                                            Id elementId) {
 318             return Optional.empty();
 319         }
 320
 321         @Override
 322         public void revert(SessionContext sessionContext, Id itemId, Id versionId, Id revisionId) {
 323
 324         }
 325
 326         @Override
 327         public ItemVersionRevisions listRevisions(SessionContext sessionContext, Id itemId, Id versionId) {
 328             return null;
 329         }
 330
 331         @Override
 332         public Optional<ElementConflict> getElementConflict(SessionContext context, ElementContext elementContext,
 333                                                                    Id id) {
 334             return Optional.empty();
 335         }
 336
 337         @Override
 338         public Collection<Item> listItems(SessionContext context) {
 339             return null;
 340         }
 341
 342         @Override
 343         public Item getItem(SessionContext context, Id itemId) {
 344             return null;
 345         }
 346
 347         @Override
 348         public void deleteItem(SessionContext context, Id itemId) {
 349
 350         }
 351
 352     }
 353
 354 }