gerrit.onap Code Review - sdc.git/blob

   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   @Mock
  36   private ItemDao itemDao;
  37   @Mock
  38   private PermissionsServices permissionsServices;
  39   @Mock
  40   private SubscriptionService subscriptionService;
  41   @InjectMocks
  42   private ItemManagerImpl itemManager;
  43
  44   @BeforeMethod
  45   public void setUp() throws Exception {
  46     MockitoAnnotations.initMocks(this);
  47   }
  48
  49   @Test
  50   public void testList() throws Exception {
  51     List<Item> returnedItems = Stream.of(createItem(ITEM_ID, ITEM_NAME, ITEM_TYPE_A),
  52         createItem("item2", "item2 name", ITEM_TYPE_B),
  53         createItem("item3", "item3 name", ITEM_TYPE_B),
  54         createItem("item4", "item4 name", ITEM_TYPE_A)).collect(Collectors.toList());
  55     doReturn(returnedItems).when(itemDao).list();
  56
  57     Collection<Item> items = itemManager.list(item -> ITEM_TYPE_B.equals(item.getType()));
  58
  59     assertEquals(items.size(), 2);
  60     assertTrue(
  61         items.stream().anyMatch(item -> returnedItems.get(1).getName().equals(item.getName())));
  62     assertTrue(
  63         items.stream().anyMatch(item -> returnedItems.get(2).getName().equals(item.getName())));
  64   }
  65
  66   @Test
  67   public void testGetNotExisting() throws Exception {
  68     Item item = itemManager.get(ITEM_ID);
  69     assertNull(item);
  70   }
  71
  72   @Test
  73   public void testGet() throws Exception {
  74     Item toBeReturned = createItem(ITEM_ID, ITEM_NAME, ITEM_TYPE_A);
  75     doReturn(toBeReturned).when(itemDao).get(any(Item.class));
  76
  77     Item item = itemManager.get(ITEM_ID);
  78
  79     assertItemEquals(item, toBeReturned);
  80   }
  81
  82   @Test
  83   public void testCreate() throws Exception {
  84     SessionContextProviderFactory.getInstance().createInterface().create(USER);
  85
  86     Item returnedItem = createItem(ITEM_ID, ITEM_NAME, ITEM_TYPE_A);
  87     doReturn(returnedItem).when(itemDao).create(any(Item.class));
  88
  89     Item inputItem = createItem(null, returnedItem.getName(), returnedItem.getType());
  90     Item item = itemManager.create(inputItem);
  91
  92     assertItemEquals(item, returnedItem);
  93     verify(permissionsServices).execute(ITEM_ID, USER, "Create_Item");
  94     verify(subscriptionService).subscribe(USER, ITEM_ID);
  95   }
  96
  97   @Test
  98   public void testUpdateNotExistingVersionStatus() throws Exception {
  99     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 100
 101     verify(itemDao, never()).update(any(Item.class));
 102   }
 103
 104   @Test
 105   public void testUpdateVersionStatusWhenNone() throws Exception {
 106     Item item = new Item();
 107     item.setId(ITEM_ID);
 108     doReturn(item).when(itemDao).get(any(Item.class));
 109
 110     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 111
 112     verify(itemDao).update(item);
 113     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 1);
 114     assertNull(item.getVersionStatusCounters().get(VersionStatus.Draft));
 115   }
 116
 117   @Test
 118   public void testUpdateVersionStatusAddFirst() throws Exception {
 119     Item item = new Item();
 120     item.setId(ITEM_ID);
 121     doReturn(item).when(itemDao).get(any(Item.class));
 122
 123     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Draft, null);
 124
 125     verify(itemDao).update(item);
 126     assertEquals(item.getVersionStatusCounters().size(), 1);
 127     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Draft).intValue(), 1);
 128   }
 129
 130   @Test
 131   public void testUpdateVersionStatus() throws Exception {
 132     Item item = new Item();
 133     item.setId(ITEM_ID);
 134     item.getVersionStatusCounters().put(VersionStatus.Certified, 2);
 135     item.getVersionStatusCounters().put(VersionStatus.Draft, 3);
 136     doReturn(item).when(itemDao).get(any(Item.class));
 137
 138     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 139
 140     verify(itemDao).update(item);
 141     assertEquals(item.getVersionStatusCounters().size(), 2);
 142     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 3);
 143     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Draft).intValue(), 2);
 144   }
 145
 146   @Test
 147   public void testUpdateVersionStatusRemoveLast() throws Exception {
 148     Item item = new Item();
 149     item.setId(ITEM_ID);
 150     item.getVersionStatusCounters().put(VersionStatus.Certified, 2);
 151     item.getVersionStatusCounters().put(VersionStatus.Draft, 1);
 152     doReturn(item).when(itemDao).get(any(Item.class));
 153
 154     itemManager.updateVersionStatus(ITEM_ID, VersionStatus.Certified, VersionStatus.Draft);
 155
 156     verify(itemDao).update(item);
 157     assertEquals(item.getVersionStatusCounters().size(), 1);
 158     assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 3);
 159     assertNull(item.getVersionStatusCounters().get(VersionStatus.Draft));
 160   }
 161
 162   private Item createItem(String id, String name, String type) {
 163     Item item = new Item();
 164     item.setId(id);
 165     item.setName(name);
 166     item.setType(type);
 167     return item;
 168   }
 169
 170   private void assertItemEquals(Item actual, Item expected) {
 171     assertEquals(actual.getId(), expected.getId());
 172     assertEquals(actual.getName(), expected.getName());
 173     assertEquals(actual.getType(), expected.getType());
 174   }
 175 }