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.onap.sdc.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
  38 import java.io.InputStream;
  39
  40 import org.onap.sdc.activityspec.be.dao.impl.ActivitySpecDaoZusammenImpl.InfoPropertyName;
  41 import org.onap.sdc.activityspec.be.dao.types.ActivitySpecEntity;
  42 import org.onap.sdc.activityspec.be.datatypes.ActivitySpecData;
  43 import org.onap.sdc.activityspec.be.datatypes.ActivitySpecParameter;
  44 import org.onap.sdc.activityspec.be.datatypes.ElementType;
  45 import org.openecomp.core.utilities.json.JsonUtil;
  46 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  47 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  48 import org.openecomp.sdc.versioning.dao.types.Version;
  49 import org.openecomp.types.ElementPropertyName;
  50 import org.testng.Assert;
  51 import org.testng.annotations.AfterMethod;
  52 import org.testng.annotations.BeforeMethod;
  53 import org.testng.annotations.Test;
  54
  55 import java.util.ArrayList;
  56 import java.util.Collection;
  57 import java.util.HashMap;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.Optional;
  61 import java.util.UUID;
  62 import java.util.stream.Collectors;
  63
  64 import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
  65
  66 public class ActivitySpecZusammenDaoImplTest {
  67
  68     private static final Version version = new Version();
  69     private static final String versionId = "1234";
  70     private static final String itemId = "5678";
  71     private static final String tenant = "dox";
  72
  73     private ZusammenAdaptorMock zusammenAdaptor;
  74     private ActivitySpecDaoZusammenImpl daoImpl;
  75     private ActivitySpecEntity entity;
  76
  77
  78     @BeforeMethod
  79     public void setUp() {
  80         SessionContextProviderFactory.getInstance().createInterface().create("test", 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<>();
  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.setInputs(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 = new ElementContext(entity.getId(), entity.getVersion().getId());
 113         Optional<ElementInfo> testElementInfo =
 114                 zusammenAdaptor.getElementInfoByName(context, elementContext, Id.ZERO, ElementType.ACTIVITYSPEC.name());
 115         Assert.assertTrue(testElementInfo.isPresent());
 116         Assert.assertEquals(testElementInfo.get().getInfo().getName(), ElementType.ACTIVITYSPEC.name());
 117         Assert.assertEquals(testElementInfo.get().getInfo().getProperty(
 118                 ActivitySpecDaoZusammenImpl.InfoPropertyName.DESCRIPTION.getValue()), entity.getDescription());
 119         Assert.assertEquals(testElementInfo.get().getInfo().getProperty(InfoPropertyName.CATEGORY.getValue()),
 120                 entity.getCategoryList());
 121         Assert.assertEquals(testElementInfo.get().getInfo()
 122                                            .getProperty(ActivitySpecDaoZusammenImpl.InfoPropertyName.NAME.getValue()),
 123                 entity.getName());
 124
 125         final Optional<Element> testElement =
 126                 zusammenAdaptor.getElement(context, elementContext, zusammenAdaptor.elementId);
 127         final InputStream data = testElement.get().getData();
 128         final ActivitySpecData activitySpecData = JsonUtil.json2Object(data, ActivitySpecData.class);
 129         Assert.assertEquals(activitySpecData.getInputs().get(0).getName(), entity.getInputs().get(0).getName());
 130     }
 131
 132     @Test
 133     public void testGet() {
 134         final ActivitySpecEntity retrieved = daoImpl.get(entity);
 135         Assert.assertEquals(retrieved.getName(), entity.getName());
 136         Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
 137         Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
 138     }
 139
 140     @Test
 141     public void testUpdate() {
 142         entity.setDescription("Update AS version1");
 143         daoImpl.update(entity);
 144         final ActivitySpecEntity retrieved = daoImpl.get(entity);
 145         Assert.assertEquals(retrieved.getName(), entity.getName());
 146         Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
 147         Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
 148     }
 149
 150     private class ZusammenAdaptorMock implements ZusammenAdaptor {
 151
 152         private ItemVersion itemVersion;
 153         private final Map<String, Element> elementMap = new HashMap<>();
 154         String elementId;
 155
 156         @Override
 157         public Optional<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
 158
 159             return Optional.ofNullable(itemVersion);
 160         }
 161
 162         @Override
 163         public Collection<ItemVersion> listPublicVersions(SessionContext context, Id itemId) {
 164             return null;
 165         }
 166
 167         @Override
 168         public ItemVersion getPublicVersion(SessionContext context, Id itemId, Id versionId) {
 169             return null;
 170         }
 171
 172         @Override
 173         public Optional<Element> getElement(SessionContext context, ElementContext elementContext, String elementId) {
 174             return Optional.of(elementMap.get(elementId));
 175         }
 176
 177         @Override
 178         public Optional<Element> getElementByName(SessionContext context, ElementContext elementContext,
 179                                                          Id parentElementId, String elementName) {
 180             //return Optional.empty();
 181             ZusammenElement element = new ZusammenElement();
 182             Info info = new Info();
 183             element.setElementId(Id.ZERO);
 184             info.addProperty("name", entity.getName());
 185             info.addProperty("description", entity.getDescription());
 186             info.addProperty("category", entity.getCategoryList());
 187             element.setInfo(info);
 188             return Optional.ofNullable(element);
 189         }
 190
 191         @Override
 192         public Collection<ElementInfo> listElements(SessionContext context, ElementContext elementContext,
 193                                                            Id parentElementId) {
 194             return null;
 195         }
 196
 197         @Override
 198         public Collection<Element> listElementData(SessionContext context, ElementContext elementContext,
 199                                                           Id parentElementId) {
 200             return elementMap.values();
 201         }
 202
 203         @Override
 204         public Collection<ElementInfo> listElementsByName(SessionContext context, ElementContext elementContext,
 205                                                                  Id parentElementId, String elementName) {
 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                              }).collect(Collectors.toList());
 218
 219         }
 220
 221         @Override
 222         public Optional<ElementInfo> getElementInfoByName(SessionContext context, ElementContext elementContext,
 223                                                                  Id parentElementId, String elementName) {
 224
 225
 226             return elementMap.values().stream()
 227                                                        .filter(element -> elementName.equals(element.getInfo()
 228                                                                                       .getProperty(
 229                                                                                         ElementPropertyName.elementType
 230                                                                                                            .name())))
 231                              .map(element -> {
 232                                  ElementInfo elementInfo = new ElementInfo();
 233                                  elementInfo.setId(element.getElementId());
 234                                  elementInfo.setInfo(element.getInfo());
 235                                  return elementInfo;
 236                              }).findAny();
 237
 238
 239         }
 240
 241         @Override
 242         public Element saveElement(SessionContext context, ElementContext elementContext, ZusammenElement element,
 243                                           String message) {
 244             if (element.getAction().equals(Action.CREATE) || element.getAction().equals(Action.UPDATE)) {
 245                 element.setElementId(new Id(UUID.randomUUID().toString()));
 246             }
 247             elementMap.put(element.getElementId().getValue(), element);
 248             elementId = element.getElementId().getValue();
 249             return element;
 250         }
 251
 252         @Override
 253         public void resolveElementConflict(SessionContext context, ElementContext elementContext,
 254                                                   ZusammenElement element, Resolution resolution) {
 255
 256         }
 257
 258         @Override
 259         public Collection<HealthInfo> checkHealth(SessionContext context) {
 260             return null;
 261         }
 262
 263         @Override
 264         public Id createItem(SessionContext context, Info info) {
 265             return null;
 266         }
 267
 268         @Override
 269         public void updateItem(SessionContext context, Id itemId, Info info) {
 270
 271         }
 272
 273         @Override
 274         public Id createVersion(SessionContext context, Id itemId, Id baseVersionId, ItemVersionData itemVersionData) {
 275             return null;
 276         }
 277
 278         @Override
 279         public void updateVersion(SessionContext context, Id itemId, Id versionId, ItemVersionData itemVersionData) {
 280
 281         }
 282
 283         @Override
 284         public ItemVersion getVersion(SessionContext context, Id itemId, Id versionId) {
 285             return null;
 286         }
 287
 288         @Override
 289         public String getVersion(SessionContext sessionContext) {
 290             return null;
 291         }
 292
 293         @Override
 294         public ItemVersionStatus getVersionStatus(SessionContext context, Id itemId, Id versionId) {
 295             return null;
 296         }
 297
 298         @Override
 299         public ItemVersionConflict getVersionConflict(SessionContext context, Id itemId, Id versionId) {
 300             return null;
 301         }
 302
 303         @Override
 304         public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 305
 306         }
 307
 308         @Override
 309         public void resetVersionHistory(SessionContext context, Id itemId, Id versionId, String changeRef) {
 310
 311         }
 312
 313
 314         @Override
 315         public void publishVersion(SessionContext context, Id itemId, Id versionId, String message) {
 316
 317         }
 318
 319         @Override
 320         public void syncVersion(SessionContext sessionContext, Id itemId, Id versionId) {
 321
 322         }
 323
 324         @Override
 325         public void forceSyncVersion(SessionContext context, Id itemId, Id versionId) {
 326
 327         }
 328
 329         @Override
 330         public Optional<ElementInfo> getElementInfo(SessionContext context, ElementContext elementContext,
 331                                                            Id elementId) {
 332             return Optional.empty();
 333         }
 334
 335         @Override
 336         public void revert(SessionContext sessionContext, Id itemId, Id versionId, Id revisionId) {
 337
 338         }
 339
 340         @Override
 341         public ItemVersionRevisions listRevisions(SessionContext sessionContext, Id itemId, Id versionId) {
 342             return null;
 343         }
 344
 345         @Override
 346         public Optional<ElementConflict> getElementConflict(SessionContext context, ElementContext elementContext,
 347                                                                    Id id) {
 348             return Optional.empty();
 349         }
 350
 351         @Override
 352         public Collection<Item> listItems(SessionContext context) {
 353             return null;
 354         }
 355
 356         @Override
 357         public Item getItem(SessionContext context, Id itemId) {
 358             return null;
 359         }
 360
 361         @Override
 362         public void deleteItem(SessionContext context, Id itemId) {
 363
 364         }
 365
 366     }
 367
 368 }