catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/ComponentCassandraDaoTest.java

   1 package org.openecomp.sdc.be.dao.cassandra;
   2
   3 import com.datastax.driver.core.Session;
   4 import com.datastax.driver.mapping.MappingManager;
   5 import com.datastax.driver.mapping.Result;
   6 import fj.data.Either;
   7 import org.apache.commons.lang3.tuple.ImmutablePair;
   8 import org.junit.Before;
   9 import org.junit.Test;
  10 import org.mockito.InjectMocks;
  11 import org.mockito.Mock;
  12 import org.mockito.Mockito;
  13 import org.mockito.MockitoAnnotations;
  14 import org.openecomp.sdc.be.dao.api.ActionStatus;
  15 import org.openecomp.sdc.be.resources.data.ComponentCacheData;
  16
  17 import java.util.*;
  18
  19 import static org.junit.Assert.assertTrue;
  20
  21 public class ComponentCassandraDaoTest {
  22
  23         @InjectMocks
  24         ComponentCassandraDao testSubject;
  25
  26         @Mock
  27         CassandraClient clientMock;
  28
  29         @Before
  30         public void setUp() throws Exception {
  31                 MockitoAnnotations.initMocks(this);
  32         }
  33
  34         @Test
  35         public void testInit() throws Exception {
  36
  37                 // default test
  38                 testSubject.init();
  39
  40                 Mockito.when(clientMock.isConnected()).thenReturn(true);
  41                 Session sessMock = Mockito.mock(Session.class);
  42                 MappingManager mappMock = Mockito.mock(MappingManager.class);
  43                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
  44                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
  45                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
  46                 testSubject.init();
  47         }
  48
  49         @Test
  50         public void testInitException() throws Exception {
  51
  52                 // default test
  53                 testSubject.init();
  54
  55                 Mockito.when(clientMock.isConnected()).thenReturn(true);
  56                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either
  57                                 .right(CassandraOperationStatus.CLUSTER_NOT_CONNECTED);
  58                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
  59                 try {
  60                         testSubject.init();
  61                 } catch (Exception e) {
  62                         assertTrue(e.getClass() == RuntimeException.class);
  63                 }
  64         }
  65
  66         @Test
  67         public void testGetComponents() throws Exception {
  68                 List<String> ids;
  69                 Either<List<ComponentCacheData>, ActionStatus> result;
  70
  71                 // test 1
  72                 ids = null;
  73                 result = testSubject.getComponents(ids);
  74
  75
  76                 // test 2
  77                 ids = new LinkedList<>();
  78                 result = testSubject.getComponents(ids);
  79
  80                 Session sessMock = Mockito.mock(Session.class);
  81                 MappingManager mappMock = Mockito.mock(MappingManager.class);
  82                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
  83                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
  84
  85                 Mockito.when(clientMock.isConnected()).thenReturn(true);
  86                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
  87                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
  88                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
  89
  90                 Result<ComponentCacheData> value2 = Mockito.mock(Result.class);
  91                 Mockito.when(componentCacheAccessorMock.getComponents(Mockito.any())).thenReturn(value2);
  92                 List<ComponentCacheData> value3 = new LinkedList<>();
  93                 value3.add(new ComponentCacheData("mock"));
  94                 Mockito.when(value2.all()).thenReturn(value3);
  95                 testSubject.init();
  96
  97                 ids.add("mock");
  98                 testSubject.getComponents(ids);
  99         }
 100
 101         @Test
 102         public void testGetComponentsNull() throws Exception {
 103                 List<String> ids = new LinkedList<>();
 104                 Either<List<ComponentCacheData>, ActionStatus> result;
 105
 106                 Session sessMock = Mockito.mock(Session.class);
 107                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 108                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 109                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 110
 111                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 112                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 113                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 114                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 115
 116                 Mockito.when(componentCacheAccessorMock.getComponents(Mockito.any())).thenReturn(null);
 117                 testSubject.init();
 118
 119                 ids.add("mock");
 120                 testSubject.getComponents(ids);
 121         }
 122
 123         @Test
 124         public void testGetComponentsException() throws Exception {
 125                 List<String> ids = new LinkedList<>();
 126                 Either<List<ComponentCacheData>, ActionStatus> result;
 127
 128                 Session sessMock = Mockito.mock(Session.class);
 129                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 130                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 131                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 132
 133                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 134                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 135                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 136                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 137
 138                 Mockito.when(componentCacheAccessorMock.getComponents(Mockito.any())).thenThrow(RuntimeException.class);
 139                 testSubject.init();
 140
 141                 ids.add("mock");
 142                 testSubject.getComponents(ids);
 143         }
 144
 145         @Test
 146         public void testGetAllComponentIdTimeAndType() throws Exception {
 147                 Either<List<ComponentCacheData>, ActionStatus> result;
 148
 149                 // default test
 150                 result = testSubject.getAllComponentIdTimeAndType();
 151
 152                 Session sessMock = Mockito.mock(Session.class);
 153                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 154                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 155                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 156
 157                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 158                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 159                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 160                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 161
 162                 Result<ComponentCacheData> value2 = Mockito.mock(Result.class);
 163                 Mockito.when(componentCacheAccessorMock.getAllComponentIdTimeAndType()).thenReturn(value2);
 164                 List<ComponentCacheData> value3 = new LinkedList<>();
 165                 value3.add(new ComponentCacheData("mock"));
 166                 Mockito.when(value2.all()).thenReturn(value3);
 167                 testSubject.init();
 168
 169                 testSubject.getAllComponentIdTimeAndType();
 170         }
 171
 172         @Test
 173         public void testGetAllComponentIdTimeAndTypeNull() throws Exception {
 174                 Either<List<ComponentCacheData>, ActionStatus> result;
 175
 176                 // default test
 177                 result = testSubject.getAllComponentIdTimeAndType();
 178
 179                 Session sessMock = Mockito.mock(Session.class);
 180                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 181                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 182                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 183
 184                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 185                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 186                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 187                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 188
 189                 Mockito.when(componentCacheAccessorMock.getAllComponentIdTimeAndType()).thenReturn(null);
 190                 testSubject.init();
 191
 192                 result = testSubject.getAllComponentIdTimeAndType();
 193         }
 194
 195         @Test
 196         public void testGetComponent() throws Exception {
 197                 String id = "";
 198                 Either<ComponentCacheData, ActionStatus> result;
 199
 200                 // test 1
 201                 id = null;
 202                 result = testSubject.getComponent(id);
 203                 //Assert.assertEquals(null, result);
 204
 205                 // test 2
 206                 id = "";
 207                 result = testSubject.getComponent(id);
 208                 //Assert.assertEquals(null, result);
 209
 210                 Session sessMock = Mockito.mock(Session.class);
 211                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 212                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 213                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 214
 215                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 216                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 217                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 218                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 219
 220                 Result<ComponentCacheData> value2 = Mockito.mock(Result.class);
 221                 Mockito.when(componentCacheAccessorMock.getComponent(Mockito.any())).thenReturn(value2);
 222                 ComponentCacheData value3 = new ComponentCacheData();
 223                 Mockito.when(value2.one()).thenReturn(value3);
 224                 testSubject.init();
 225
 226                 result = testSubject.getComponent(id);
 227         }
 228
 229         @Test
 230         public void testGetComponentNull1() throws Exception {
 231                 String id = "";
 232                 Either<ComponentCacheData, ActionStatus> result;
 233
 234                 Session sessMock = Mockito.mock(Session.class);
 235                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 236                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 237                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 238
 239                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 240                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 241                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 242                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 243
 244                 Mockito.when(componentCacheAccessorMock.getComponent(Mockito.any())).thenReturn(null);
 245                 testSubject.init();
 246
 247                 result = testSubject.getComponent(id);
 248         }
 249
 250         @Test
 251         public void testGetComponentNull2() throws Exception {
 252                 String id = "";
 253                 Either<ComponentCacheData, ActionStatus> result;
 254
 255                 // test 1
 256                 id = null;
 257                 result = testSubject.getComponent(id);
 258                 //Assert.assertEquals(null, result);
 259
 260                 // test 2
 261                 id = "";
 262                 result = testSubject.getComponent(id);
 263                 //Assert.assertEquals(null, result);
 264
 265                 Session sessMock = Mockito.mock(Session.class);
 266                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 267                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 268                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 269
 270                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 271                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 272                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 273                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 274
 275                 Result<ComponentCacheData> value2 = Mockito.mock(Result.class);
 276                 Mockito.when(componentCacheAccessorMock.getComponent(Mockito.any())).thenReturn(value2);
 277                 Mockito.when(value2.one()).thenReturn(null);
 278                 testSubject.init();
 279
 280                 result = testSubject.getComponent(id);
 281         }
 282
 283         @Test
 284         public void testSaveComponent() throws Exception {
 285                 ComponentCacheData componentCacheData = null;
 286                 CassandraOperationStatus result;
 287
 288                 // default test
 289                 result = testSubject.saveComponent(componentCacheData);
 290         }
 291
 292         @Test
 293         public void testIsTableEmpty() throws Exception {
 294                 String tableName = "";
 295                 Either<Boolean, CassandraOperationStatus> result;
 296
 297                 // default test
 298                 result = testSubject.isTableEmpty(tableName);
 299         }
 300
 301         @Test
 302         public void testGetComponents_1() throws Exception {
 303                 Map<String, Long> idToTimestampMap = null;
 304                 Either<ImmutablePair<List<ComponentCacheData>, Set<String>>, ActionStatus> result;
 305
 306                 // test 1
 307                 idToTimestampMap = null;
 308                 result = testSubject.getComponents(idToTimestampMap);
 309                 //Assert.assertEquals(null, result);
 310
 311                 Session sessMock = Mockito.mock(Session.class);
 312                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 313                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 314                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 315
 316                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 317                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 318                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 319                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 320
 321                 Result<ComponentCacheData> value2 = Mockito.mock(Result.class);
 322                 Mockito.when(componentCacheAccessorMock.getComponents(Mockito.any(List.class))).thenReturn(value2);
 323                 List<ComponentCacheData> value3 = new LinkedList<>();
 324                 ComponentCacheData e = new ComponentCacheData("mock");
 325                 Mockito.when(value2.all()).thenReturn(value3);
 326                 testSubject.init();
 327
 328                 idToTimestampMap = new HashMap<>();
 329                 idToTimestampMap.put("mock", 0L);
 330                 e.setModificationTime(new Date());
 331                 value3.add(e);
 332                 result = testSubject.getComponents(idToTimestampMap);
 333         }
 334
 335         @Test
 336         public void testGetComponents_1Null() throws Exception {
 337                 Map<String, Long> idToTimestampMap = null;
 338                 Either<ImmutablePair<List<ComponentCacheData>, Set<String>>, ActionStatus> result;
 339
 340                 Session sessMock = Mockito.mock(Session.class);
 341                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 342                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 343                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 344
 345                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 346                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 347                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 348                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 349
 350                 Mockito.when(componentCacheAccessorMock.getComponents(Mockito.any(List.class))).thenReturn(null);
 351                 testSubject.init();
 352
 353                 idToTimestampMap = new HashMap<>();
 354                 idToTimestampMap.put("mock", 0L);
 355                 result = testSubject.getComponents(idToTimestampMap);
 356         }
 357
 358         @Test
 359         public void testGetComponents_1Exception() throws Exception {
 360                 Map<String, Long> idToTimestampMap = null;
 361                 Either<ImmutablePair<List<ComponentCacheData>, Set<String>>, ActionStatus> result;
 362
 363                 Session sessMock = Mockito.mock(Session.class);
 364                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 365                 ComponentCacheAccessor componentCacheAccessorMock = Mockito.mock(ComponentCacheAccessor.class);
 366                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 367
 368                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 369                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 370                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 371                 Mockito.when(mappMock.createAccessor(ComponentCacheAccessor.class)).thenReturn(componentCacheAccessorMock);
 372
 373                 Mockito.when(componentCacheAccessorMock.getComponents(Mockito.any(List.class))).thenThrow(RuntimeException.class);
 374                 testSubject.init();
 375
 376                 idToTimestampMap = new HashMap<>();
 377                 idToTimestampMap.put("mock", 0L);
 378                 result = testSubject.getComponents(idToTimestampMap);
 379         }
 380
 381         @Test
 382         public void testDeleteComponent() throws Exception {
 383                 String id = "";
 384                 CassandraOperationStatus result;
 385
 386                 // default test
 387                 result = testSubject.deleteComponent(id);
 388         }
 389 }