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

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