openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/ItemManagerImplTest.java

   1 package org.openecomp.sdc.versioning.impl;
   2
   3 import org.mockito.InjectMocks;
   4 import org.mockito.Mock;
   5 import org.mockito.MockitoAnnotations;
   6 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
   7 import org.openecomp.sdc.itempermissions.PermissionsServices;
   8 import org.openecomp.sdc.notification.services.SubscriptionService;
   9 import org.openecomp.sdc.versioning.dao.ItemDao;
  10 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  11 import org.openecomp.sdc.versioning.types.Item;
  12 import org.testng.annotations.BeforeMethod;
  13 import org.testng.annotations.Test;
  14
  15 import java.util.Collection;
  16 import java.util.List;
  17 import java.util.stream.Collectors;
  18 import java.util.stream.Stream;
  19
  20 import static org.mockito.Matchers.any;
  21 import static org.mockito.Mockito.doReturn;
  22 import static org.mockito.Mockito.never;
  23 import static org.mockito.Mockito.verify;
  24 import static org.testng.Assert.assertEquals;
  25 import static org.testng.Assert.assertNull;
  26 import static org.testng.Assert.assertTrue;
  27
  28 public class ItemManagerImplTest {
  29
  30   private static final String USER = "user1";
  31   private static final String ITEM_ID = "item1";
  32   private static final String ITEM_NAME = "item 1 name";
  33   private static final String ITEM_TYPE_A = "A";
  34   private static final String ITEM_TYPE_B = "B";
  35   private static final String tenant = "dox";
  36   @Mock
  37   private ItemDao itemDao;
  38   @Mock
  39   private PermissionsServices permissionsServices;
  40   @Mock
  41   private SubscriptionService subscriptionService;
  42   @InjectMocks
  43   private ItemManagerImpl itemManager;
  44
  45   @BeforeMethod
  46   public void setUp() throws Exception {
  47     MockitoAnnotations.initMocks(this);
  48   }
  49
  50   @Test
  51   public void testList() throws Exception {
  52     List<Item> returnedItems = Stream.of(createItem(ITEM_ID, ITEM_NAME, ITEM_TYPE_A),
  53         createItem("item2", "item2 name", ITEM_TYPE_B),
  54         createItem("item3", "item3 name", ITEM_TYPE_B),
  55         createItem("item4", "item4 name", ITEM_TYPE_A)).collect(Collectors.toList());
  56     doReturn(returnedItems).when(itemDao).list();
  57
  58     Collection<Item> items = itemManager.list(item -> ITEM_TYPE_B.equals(item.getType()));
  59
  60     assertEquals(items.size(), 2);
  61     assertTrue(
  62         items.stream().anyMatch(item -> returnedItems.get(1).getName().equals(item.getName())));
  63     assertTrue(
  64         items.stream().anyMatch(item -> returnedItems.get(2).getName().equals(item.getName())));
  65   }
  66
  67   @Test
  68   public void testGetNotExisting() throws Exception {
  69     Item item = itemManager.get(ITEM_ID);
  70     assertNull(item);
  71   }
  72
  73   @Test
  74   public void testGet() throws Exception {
  75     Item toBeReturned = createItem(ITEM_ID, ITEM_NAME, ITEM_TYPE_A);
  76     doReturn(toBeReturned).when(itemDao).get(any(Item.class));
  77
  78     Item item = itemManager.get(ITEM_ID);
  79
  80     assertItemEquals(item, toBeReturned);
  81   }
  82
  83   @Test
  84   public void testCreate() throws Exception {
  85     SessionContextProviderFactory.getInstance().createInterface().create(USER, tenant);
  86
  87     Item returnedItem = createItem(ITEM_ID, ITEM_NAME, ITEM_TYPE_A);
  88     doReturn(returnedItem).when(itemDao).create(any(Item.class));
  89
  90     Item inputItem = createItem(null, returnedItem.getName(), returnedItem.getType());
  91     Item item = itemManager.create(inputItem);
  92
  93     assertItemEquals(item, returnedItem);
  94     verify(permissionsServices).execute(ITEM_ID, USER, "Create_Item");
  95     verify(subscriptionService).subscribe(USER, ITEM_ID);
  96   }
  97
  98   @Test
  99   public void testUpdateNotExistingVersionStatus() throws Exception {
 100     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 101
 102     verify(itemDao, never()).update(any(Item.class));
 103   }
 104
 105   @Test
 106   public void testUpdateVersionStatusWhenNone() throws Exception {
 107     Item item = new Item();
 108     item.setId(ITEM_ID);
 109     doReturn(item).when(itemDao).get(any(Item.class));
 110
 111     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 112
 113     verify(itemDao).update(item);
 114     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 1);
 115     assertNull(item.getVersionStatusCounters().get(VersionStatus.Draft));
 116   }
 117
 118   @Test
 119   public void testUpdateVersionStatusAddFirst() throws Exception {
 120     Item item = new Item();
 121     item.setId(ITEM_ID);
 122     doReturn(item).when(itemDao).get(any(Item.class));
 123
 124     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Draft, null);
 125
 126     verify(itemDao).update(item);
 127     assertEquals(item.getVersionStatusCounters().size(), 1);
 128     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Draft).intValue(), 1);
 129   }
 130
 131   @Test
 132   public void testUpdateVersionStatus() throws Exception {
 133     Item item = new Item();
 134     item.setId(ITEM_ID);
 135     item.getVersionStatusCounters().put(VersionStatus.Certified, 2);
 136     item.getVersionStatusCounters().put(VersionStatus.Draft, 3);
 137     doReturn(item).when(itemDao).get(any(Item.class));
 138
 139     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 140
 141     verify(itemDao).update(item);
 142     assertEquals(item.getVersionStatusCounters().size(), 2);
 143     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 3);
 144     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Draft).intValue(), 2);
 145   }
 146
 147   @Test
 148   public void testUpdateVersionStatusRemoveLast() throws Exception {
 149     Item item = new Item();
 150     item.setId(ITEM_ID);
 151     item.getVersionStatusCounters().put(VersionStatus.Certified, 2);
 152     item.getVersionStatusCounters().put(VersionStatus.Draft, 1);
 153     doReturn(item).when(itemDao).get(any(Item.class));
 154
 155     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 156
 157     verify(itemDao).update(item);
 158     assertEquals(item.getVersionStatusCounters().size(), 1);
 159     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 3);
 160     assertNull(item.getVersionStatusCounters().get(VersionStatus.Draft));
 161   }
 162
 163   private Item createItem(String id, String name, String type) {
 164     Item item = new Item();
 165     item.setId(id);
 166     item.setName(name);
 167     item.setType(type);
 168     return item;
 169   }
 170
 171   private void assertItemEquals(Item actual, Item expected) {
 172     assertEquals(actual.getId(), expected.getId());
 173     assertEquals(actual.getName(), expected.getName());
 174     assertEquals(actual.getType(), expected.getType());
 175   }
 176 }