gerrit.onap Code Review - sdc.git/blob

   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.openecomp.activityspec.be.dao.impl;
  18
  19 import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
  20 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementConflict;
  21 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
  22 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict;
  23 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
  24 import com.amdocs.zusammen.commons.health.data.HealthInfo;
  25 import com.amdocs.zusammen.datatypes.Id;
  26 import com.amdocs.zusammen.datatypes.SessionContext;
  27 import com.amdocs.zusammen.datatypes.item.Action;
  28 import com.amdocs.zusammen.datatypes.item.ElementContext;
  29 import com.amdocs.zusammen.datatypes.item.Info;
  30 import com.amdocs.zusammen.datatypes.item.Item;
  31 import com.amdocs.zusammen.datatypes.item.ItemVersion;
  32 import com.amdocs.zusammen.datatypes.item.ItemVersionData;
  33 import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
  34 import com.amdocs.zusammen.datatypes.item.Resolution;
  35 import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
  36 import com.amdocs.zusammen.datatypes.itemversion.Tag;
  37 import java.io.InputStream;
  38 import org.openecomp.activityspec.be.dao.impl.ActivitySpecDaoZusammenImpl.InfoPropertyName;
  39 import org.openecomp.activityspec.be.datatypes.ActivitySpecData;
  40 import org.openecomp.activityspec.be.datatypes.ActivitySpecParameter;
  41 import org.openecomp.core.utilities.json.JsonUtil;
  42 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  43 import org.openecomp.activityspec.be.dao.types.ActivitySpecEntity;
  44 import org.openecomp.activityspec.be.datatypes.ElementType;
  45 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  46 import org.openecomp.sdc.versioning.dao.types.Version;
  47 import org.openecomp.types.ElementPropertyName;
  48 import org.testng.Assert;
  49 import org.testng.annotations.AfterMethod;
  50 import org.testng.annotations.BeforeMethod;
  51 import org.testng.annotations.Test;
  52
  53 import java.util.ArrayList;
  54 import java.util.Collection;
  55 import java.util.HashMap;
  56 import java.util.List;
  57 import java.util.Map;
  58 import java.util.Optional;
  59 import java.util.UUID;
  60 import java.util.stream.Collectors;
  61
  62 import static org.mockito.Mockito.verify;
  63 import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
  64
  65 public class ActivitySpecZusammenDaoImplTest {
  66
  67   private static final Version version = new Version();
  68   private static final String versionId = "1234";
  69   private static final String itemId = "5678";
  70   private static final String tenant = "dox";
  71
  72   ZusammenAdaptorMock zusammenAdaptor;
  73   ActivitySpecDaoZusammenImpl daoImpl;
  74   ActivitySpecEntity entity;
  75
  76
  77   @BeforeMethod
  78   public void setUp(){
  79     SessionContextProviderFactory.getInstance().createInterface().create("test",
  80         tenant);
  81     zusammenAdaptor = new ZusammenAdaptorMock();
  82     daoImpl = new ActivitySpecDaoZusammenImpl(zusammenAdaptor);
  83     entity = new ActivitySpecEntity();
  84     entity = new ActivitySpecEntity();
  85
  86     entity.setId(itemId);
  87     version.setId(versionId);
  88     entity.setVersion(version);
  89     entity.setName("activitySpec");
  90     List<String> categoryList = new ArrayList<String>();
  91     categoryList.add("category1");
  92     entity.setCategoryList(categoryList);
  93     ActivitySpecParameter inputParams = new ActivitySpecParameter("dbhost", "String");
  94     inputParams.setValue("localhost");
  95     List<ActivitySpecParameter> inputs = new ArrayList<>();
  96     inputs.add(inputParams);
  97     entity.setInputParameters(inputs);
  98   }
  99
 100   @AfterMethod
 101   public void tearDown(){
 102     SessionContextProviderFactory.getInstance().createInterface().close();
 103   }
 104
 105   @Test
 106   public void testCreate() {
 107     ItemVersion itemVersionmock = new ItemVersion();
 108     itemVersionmock.setId(new Id());
 109
 110     daoImpl.create(entity);
 111     SessionContext context = createSessionContext();
 112     ElementContext elementContext =
 113         new ElementContext(entity.getId(), entity.getVersion().getId());
 114     Optional<ElementInfo> testElementInfo =
 115         zusammenAdaptor.getElementInfoByName(context, elementContext,Id.ZERO,
 116             ElementType.ACTIVITYSPEC.name() );
 117     Assert.assertTrue(testElementInfo.isPresent());
 118     Assert.assertEquals(testElementInfo.get().getInfo().getName(), ElementType.ACTIVITYSPEC.name());
 119     Assert.assertEquals(testElementInfo.get().getInfo().getProperty(
 120         ActivitySpecDaoZusammenImpl.InfoPropertyName.DESCRIPTION.getValue()),
 121         entity.getDescription());
 122     Assert.assertEquals(testElementInfo.get().getInfo().getProperty(
 123         InfoPropertyName.CATEGORY.getValue()),
 124         entity.getCategoryList());
 125     Assert.assertEquals(testElementInfo.get().getInfo().getProperty(
 126         ActivitySpecDaoZusammenImpl.InfoPropertyName.NAME.getValue()),
 127         entity.getName());
 128
 129     final Optional<Element> testElement = zusammenAdaptor
 130         .getElement(context, elementContext, zusammenAdaptor.elementId);
 131     final InputStream data = testElement.get().getData();
 132     final ActivitySpecData activitySpecData = JsonUtil.json2Object(data, ActivitySpecData.class);
 133     Assert.assertEquals(activitySpecData.getInputParameters().get(0).getName(),
 134         entity.getInputParameters().get(0).getName());
 135   }
 136
 137   @Test
 138   public void testGet () {
 139     SessionContext context = createSessionContext();
 140     ElementContext elementContext =
 141         new ElementContext(entity.getId(), entity.getVersion().getId());
 142     final ActivitySpecEntity retrieved = daoImpl.get(entity);
 143     Assert.assertEquals(retrieved.getName(), entity.getName());
 144     Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
 145     Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
 146   }
 147
 148   @Test
 149   public void testUpdate () {
 150     SessionContext context = createSessionContext();
 151     ElementContext elementContext =
 152         new ElementContext(entity.getId(), entity.getVersion().getId());
 153     entity.setDescription("Update AS version1");
 154     daoImpl.update(entity);
 155     final ActivitySpecEntity retrieved = daoImpl.get(entity);
 156     Assert.assertEquals(retrieved.getName(), entity.getName());
 157     Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
 158     Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
 159   }
 160
 161   private class ZusammenAdaptorMock implements ZusammenAdaptor {
 162
 163     private ItemVersion itemVersion;
 164     private Map<String,Element> elementMap = new HashMap<>();
 165     String elementId;
 166
 167   /*  private void setItemVersion(ItemVersion itemVersion) {
 168       this.itemVersion = itemVersion;
 169     }
 170
 171     private void addElementInfo(String key, ElementInfo elementInfo) {
 172       elementInfoMap.put(key, elementInfo);
 173     }
 174
 175     private void addElement(Element element) {
 176       elements.add(element);
 177     }*/
 178
 179     @Override
 180     public Optional<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
 181
 182       return Optional.ofNullable(itemVersion);
 183     }
 184
 185     @Override
 186     public Collection<ItemVersion> listPublicVersions(SessionContext context, Id itemId) {
 187       return null;
 188     }
 189
 190     @Override
 191     public ItemVersion getPublicVersion(SessionContext context, Id itemId, Id versionId) {
 192       return null;
 193     }
 194
 195     @Override
 196     public Optional<Element> getElement(SessionContext context, ElementContext elementContext,
 197                                         String elementId) {
 198       return Optional.of(elementMap.get(elementId));
 199     }
 200
 201     @Override
 202     public Optional<Element> getElementByName(SessionContext context,
 203                                               ElementContext elementContext,
 204                                               Id parentElementId, String elementName) {
 205       //return Optional.empty();
 206       ZusammenElement element = new ZusammenElement();
 207       Info info = new Info();
 208       element.setElementId(Id.ZERO);
 209       info.addProperty("name", entity.getName());
 210       info.addProperty("description", entity.getDescription());
 211       info.addProperty("category", entity.getCategoryList());
 212       element.setInfo(info);
 213       return Optional.ofNullable(element);
 214     }
 215
 216     @Override
 217     public Collection<ElementInfo> listElements(SessionContext context,
 218                                                 ElementContext elementContext,
 219                                                 Id parentElementId) {
 220       return null;
 221     }
 222
 223     @Override
 224     public Collection<Element> listElementData(SessionContext context,
 225                                                ElementContext elementContext,
 226                                                Id parentElementId) {
 227       return elementMap.values();
 228     }
 229
 230     @Override
 231     public Collection<ElementInfo> listElementsByName(SessionContext context,
 232                                                       ElementContext elementContext,
 233                                                       Id parentElementId, String elementName) {
 234
 235       return elementMap.values().stream().
 236           filter(element->elementName.equals(element.getInfo().getProperty
 237               (ElementPropertyName.elementType.name()))).map(element->{
 238         ElementInfo elementInfo = new ElementInfo();
 239         elementInfo.setId(element.getElementId());
 240         elementInfo.setInfo(element.getInfo());
 241         return elementInfo;
 242       }).collect(Collectors.toList());
 243
 244     }
 245
 246     @Override
 247     public Optional<ElementInfo> getElementInfoByName(SessionContext context,
 248                                                       ElementContext elementContext,
 249                                                       Id parentElementId, String elementName) {
 250
 251
 252       return elementMap.values().stream().
 253           filter(element -> elementName.equals(element.getInfo().getProperty
 254               (ElementPropertyName.elementType.name()))).map(element -> {
 255         ElementInfo elementInfo = new ElementInfo();
 256         elementInfo.setId(element.getElementId());
 257         elementInfo.setInfo(element.getInfo());
 258         return elementInfo;
 259       }).findAny();
 260
 261
 262
 263     }
 264
 265     @Override
 266     public Element saveElement(SessionContext context, ElementContext elementContext,
 267                                ZusammenElement element, String message) {
 268       if(element.getAction().equals(Action.CREATE) ||
 269           element.getAction().equals(Action.UPDATE)){
 270         element.setElementId(new Id(UUID.randomUUID().toString()));
 271       }
 272       elementMap.put(element.getElementId().getValue(),element);
 273       elementId = element.getElementId().getValue();
 274       return element;
 275     }
 276
 277     @Override
 278     public void resolveElementConflict(SessionContext context, ElementContext elementContext,
 279                                        ZusammenElement element, Resolution resolution) {
 280
 281     }
 282
 283     @Override
 284     public Collection<HealthInfo> checkHealth(SessionContext context) {
 285       return null;
 286     }
 287
 288     @Override
 289     public Id createItem(SessionContext context, Info info) {
 290       return null;
 291     }
 292
 293     @Override
 294     public void updateItem(SessionContext context, Id itemId, Info info) {
 295
 296     }
 297
 298     @Override
 299     public Id createVersion(SessionContext context, Id itemId, Id baseVersionId,
 300                             ItemVersionData itemVersionData) {
 301       return null;
 302     }
 303
 304     @Override
 305     public void updateVersion(SessionContext context, Id itemId, Id versionId,
 306                               ItemVersionData itemVersionData) {
 307
 308     }
 309
 310     @Override
 311     public ItemVersion getVersion(SessionContext context, Id itemId, Id versionId) {
 312       return null;
 313     }
 314
 315     @Override
 316     public ItemVersionStatus getVersionStatus(SessionContext context, Id itemId, Id versionId) {
 317       return null;
 318     }
 319
 320     @Override
 321     public ItemVersionConflict getVersionConflict(SessionContext context, Id itemId, Id versionId) {
 322       return null;
 323     }
 324
 325     @Override
 326     public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 327
 328     }
 329
 330     @Override
 331     public void resetVersionHistory(SessionContext context, Id itemId, Id versionId,
 332                                     String changeRef) {
 333
 334     }
 335
 336
 337     @Override
 338     public void publishVersion(SessionContext context, Id itemId, Id versionId, String message) {
 339
 340     }
 341
 342     @Override
 343     public void syncVersion(SessionContext sessionContext, Id itemId, Id versionId) {
 344
 345     }
 346
 347     @Override
 348     public void forceSyncVersion(SessionContext context, Id itemId, Id versionId) {
 349
 350     }
 351
 352     @Override
 353     public Optional<ElementInfo> getElementInfo(SessionContext context,
 354                                                 ElementContext elementContext,
 355                                                 Id elementId) {
 356       return Optional.empty();
 357     }
 358
 359     @Override
 360     public String getVersion(SessionContext sessionContext) {
 361       return null;
 362     }
 363
 364     @Override
 365     public void revert(SessionContext sessionContext, Id itemId, Id versionId,
 366                        Id revisionId) {
 367
 368     }
 369
 370     @Override
 371     public ItemVersionRevisions listRevisions(SessionContext sessionContext, Id itemId,
 372                                               Id versionId) {
 373       return null;
 374     }
 375
 376     @Override
 377     public Optional<ElementConflict> getElementConflict(SessionContext context,
 378                                                         ElementContext elementContext,
 379                                                         Id id) {
 380       return Optional.empty();
 381     }
 382
 383     @Override
 384     public Collection<Item> listItems(SessionContext context) {
 385       return null;
 386     }
 387
 388     @Override
 389     public Item getItem(SessionContext context, Id itemId) {
 390       return null;
 391     }
 392
 393     @Override
 394     public void deleteItem(SessionContext context, Id itemId) {
 395
 396     }
 397
 398   }
 399
 400 }