catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/AuditCassandraDaoTest.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.auditing.*;
  36
  37 import java.util.LinkedList;
  38 import java.util.List;
  39
  40 public class AuditCassandraDaoTest {
  41
  42         @InjectMocks
  43         AuditCassandraDao testSubject;
  44
  45         @Mock
  46         AuditAccessor auditAccessor;
  47
  48         @Mock
  49         CassandraClient client;
  50
  51         @Before
  52         public void setUp() throws Exception {
  53                 MockitoAnnotations.openMocks(this);
  54         }
  55
  56         @Test(expected = RuntimeException.class)
  57         public void testInit() throws Exception {
  58                 Mockito.when(client.isConnected()).thenReturn(true);
  59                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either
  60                                 .right(CassandraOperationStatus.CLUSTER_NOT_CONNECTED);
  61                 Mockito.when(client.connect(Mockito.anyString())).thenReturn(value);
  62                 testSubject.init();
  63         }
  64
  65         @Test
  66         public void testInitFail2() throws Exception {
  67                 Mockito.when(client.isConnected()).thenReturn(false);
  68                 testSubject.init();
  69         }
  70
  71         @Test
  72         public void testGetListOfDistributionStatuses() throws Exception {
  73                 String did = "";
  74                 Either<List<DistributionStatusEvent>, ActionStatus> result;
  75
  76                 Result<DistributionStatusEvent> value = Mockito.mock(Result.class);
  77                 LinkedList<DistributionStatusEvent> value2 = new LinkedList<>();
  78                 value2.add(new DistributionStatusEvent());
  79                 Mockito.when(value.all()).thenReturn(value2);
  80                 Mockito.when(auditAccessor.getListOfDistributionStatuses(Mockito.anyString())).thenReturn(value);
  81
  82                 // default test
  83                 result = testSubject.getListOfDistributionStatuses(did);
  84         }
  85
  86         @Test
  87         public void testGetListOfDistributionStatusesException() throws Exception {
  88                 String did = "";
  89                 Either<List<DistributionStatusEvent>, ActionStatus> result;
  90
  91                 Mockito.when(auditAccessor.getListOfDistributionStatuses(Mockito.anyString()))
  92                                 .thenThrow(RuntimeException.class);
  93
  94                 // default test
  95                 result = testSubject.getListOfDistributionStatuses(did);
  96         }
  97
  98         @Test
  99         public void testGetListOfDistributionStatusesEmptyList() throws Exception {
 100                 String did = "";
 101                 Either<List<DistributionStatusEvent>, ActionStatus> result;
 102
 103                 // default test
 104                 result = testSubject.getListOfDistributionStatuses(did);
 105         }
 106
 107         @Test
 108         public void testGetDistributionDeployByStatus() throws Exception {
 109                 String did = "";
 110                 String action = "";
 111                 String status = "";
 112                 Either<List<DistributionDeployEvent>, ActionStatus> result;
 113
 114                 Result<DistributionDeployEvent> value = Mockito.mock(Result.class);
 115                 LinkedList<DistributionDeployEvent> value2 = new LinkedList<>();
 116                 value2.add(new DistributionDeployEvent());
 117                 Mockito.when(value.all()).thenReturn(value2);
 118                 Mockito.when(auditAccessor.getDistributionDeployByStatus(Mockito.anyString(), Mockito.anyString(),
 119                                 Mockito.anyString())).thenReturn(value);
 120
 121                 // default test
 122                 result = testSubject.getDistributionDeployByStatus(did, action, status);
 123         }
 124
 125         @Test
 126         public void testGetDistributionDeployByStatusEmptyList() throws Exception {
 127                 String did = "";
 128                 String action = "";
 129                 String status = "";
 130                 Either<List<DistributionDeployEvent>, ActionStatus> result;
 131
 132                 Result<DistributionDeployEvent> value = Mockito.mock(Result.class);
 133                 LinkedList<DistributionDeployEvent> value2 = new LinkedList<>();
 134                 value2.add(new DistributionDeployEvent());
 135                 Mockito.when(value.all()).thenReturn(value2);
 136                 Mockito.when(auditAccessor.getDistributionDeployByStatus(Mockito.anyString(), Mockito.anyString(),
 137                                 Mockito.anyString())).thenReturn(null);
 138
 139                 // default test
 140                 result = testSubject.getDistributionDeployByStatus(did, action, status);
 141         }
 142
 143         @Test
 144         public void testGetDistributionDeployByStatusException() throws Exception {
 145                 String did = "";
 146                 String action = "";
 147                 String status = "";
 148                 Either<List<DistributionDeployEvent>, ActionStatus> result;
 149
 150                 Mockito.when(auditAccessor.getDistributionDeployByStatus(Mockito.anyString(), Mockito.anyString(),
 151                                 Mockito.anyString())).thenThrow(RuntimeException.class);
 152
 153                 // default test
 154                 result = testSubject.getDistributionDeployByStatus(did, action, status);
 155         }
 156
 157         @Test
 158         public void testGetDistributionRequest() throws Exception {
 159                 String did = "";
 160                 String action = "";
 161                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 162
 163                 // default test
 164                 result = testSubject.getDistributionRequest(did, action);
 165         }
 166
 167         @Test
 168         public void testGetDistributionRequestList() throws Exception {
 169                 String did = "";
 170                 String action = "";
 171                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 172
 173                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 174                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 175                 value2.add(new ResourceAdminEvent());
 176                 Mockito.when(value.all()).thenReturn(value2);
 177                 Mockito.when(auditAccessor.getDistributionRequest(Mockito.anyString(), Mockito.anyString())).thenReturn(value);
 178
 179                 // default test
 180                 result = testSubject.getDistributionRequest(did, action);
 181         }
 182
 183         @Test
 184         public void testGetDistributionRequestException() throws Exception {
 185                 String did = "";
 186                 String action = "";
 187                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 188
 189                 Mockito.when(auditAccessor.getDistributionRequest(Mockito.anyString(), Mockito.anyString()))
 190                                 .thenThrow(RuntimeException.class);
 191
 192                 // default test
 193                 result = testSubject.getDistributionRequest(did, action);
 194         }
 195
 196         @Test
 197         public void testGetDistributionNotify() throws Exception {
 198                 String did = "";
 199                 String action = "";
 200                 Either<List<DistributionNotificationEvent>, ActionStatus> result;
 201
 202                 Result<DistributionNotificationEvent> value = Mockito.mock(Result.class);
 203                 List<DistributionNotificationEvent> value2 = new LinkedList<>();
 204                 value2.add(new DistributionNotificationEvent());
 205                 Mockito.when(value.all()).thenReturn(value2);
 206
 207                 Mockito.when(auditAccessor.getDistributionNotify(Mockito.anyString(), Mockito.anyString())).thenReturn(value);
 208
 209                 // default test
 210                 result = testSubject.getDistributionNotify(did, action);
 211         }
 212
 213         @Test
 214         public void testGetDistributionNotifyException() throws Exception {
 215                 String did = "";
 216                 String action = "";
 217                 Either<List<DistributionNotificationEvent>, ActionStatus> result;
 218
 219                 Mockito.when(auditAccessor.getDistributionNotify(Mockito.anyString(), Mockito.anyString()))
 220                                 .thenThrow(RuntimeException.class);
 221
 222                 // default test
 223                 result = testSubject.getDistributionNotify(did, action);
 224         }
 225
 226         @Test
 227         public void testGetDistributionNotifyNull() throws Exception {
 228                 String did = "";
 229                 String action = "";
 230                 Either<List<DistributionNotificationEvent>, ActionStatus> result;
 231
 232                 // default test
 233                 result = testSubject.getDistributionNotify(did, action);
 234         }
 235
 236         @Test
 237         public void testGetByServiceInstanceId() throws Exception {
 238                 String serviceInstanceId = "";
 239                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 240
 241                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 242                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 243                 value2.add(new ResourceAdminEvent());
 244                 Mockito.when(value.all()).thenReturn(value2);
 245                 Mockito.when(auditAccessor.getByServiceInstanceId(Mockito.anyString())).thenReturn(value);
 246                 // default test
 247                 result = testSubject.getByServiceInstanceId(serviceInstanceId);
 248         }
 249
 250         @Test
 251         public void testGetByServiceInstanceIdException() throws Exception {
 252                 String serviceInstanceId = "";
 253                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 254
 255                 Mockito.when(auditAccessor.getByServiceInstanceId(Mockito.anyString())).thenThrow(RuntimeException.class);
 256                 // default test
 257                 result = testSubject.getByServiceInstanceId(serviceInstanceId);
 258         }
 259
 260         @Test
 261         public void testGetByServiceInstanceIdNull() throws Exception {
 262                 String serviceInstanceId = "";
 263                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 264
 265                 // default test
 266                 result = testSubject.getByServiceInstanceId(serviceInstanceId);
 267         }
 268
 269         @Test
 270         public void testGetServiceDistributionStatusesList() throws Exception {
 271                 String serviceInstanceId = "";
 272                 Either<List<? extends AuditingGenericEvent>, ActionStatus> result;
 273
 274                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 275                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 276                 value2.add(new ResourceAdminEvent());
 277                 Mockito.when(value.all()).thenReturn(value2);
 278                 Mockito.when(auditAccessor.getServiceDistributionStatus(Mockito.anyString())).thenReturn(value);
 279
 280                 // default test
 281                 result = testSubject.getServiceDistributionStatusesList(serviceInstanceId);
 282         }
 283
 284         @Test
 285         public void testGetServiceDistributionStatusesList2() throws Exception {
 286                 String serviceInstanceId = "";
 287                 Either<List<? extends AuditingGenericEvent>, ActionStatus> result;
 288
 289                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 290                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 291                 value2.add(new ResourceAdminEvent());
 292                 Mockito.when(value.all()).thenReturn(value2);
 293                 Mockito.when(auditAccessor.getServiceDistributionStatus(Mockito.anyString())).thenReturn(value);
 294
 295                 Result<DistributionDeployEvent> value3 = Mockito.mock(Result.class);
 296                 List<DistributionDeployEvent> value4 = new LinkedList<>();
 297                 value4.add(new DistributionDeployEvent());
 298                 Mockito.when(value3.all()).thenReturn(value4);
 299                 Mockito.when(auditAccessor.getServiceDistributionDeploy(Mockito.anyString())).thenReturn(value3);
 300
 301                 // default test
 302                 result = testSubject.getServiceDistributionStatusesList(serviceInstanceId);
 303         }
 304
 305         @Test
 306         public void testGetServiceDistributionStatusesList3() throws Exception {
 307                 String serviceInstanceId = "";
 308                 Either<List<? extends AuditingGenericEvent>, ActionStatus> result;
 309
 310                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 311                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 312                 value2.add(new ResourceAdminEvent());
 313                 Mockito.when(value.all()).thenReturn(value2);
 314                 Mockito.when(auditAccessor.getServiceDistributionStatus(Mockito.anyString())).thenReturn(value);
 315
 316                 Result<DistributionDeployEvent> value3 = Mockito.mock(Result.class);
 317                 List<DistributionDeployEvent> value4 = new LinkedList<>();
 318                 value4.add(new DistributionDeployEvent());
 319                 Mockito.when(value3.all()).thenReturn(value4);
 320                 Mockito.when(auditAccessor.getServiceDistributionDeploy(Mockito.anyString())).thenReturn(value3);
 321
 322
 323                 Result<DistributionNotificationEvent> value5 = Mockito.mock(Result.class);
 324                 List<DistributionNotificationEvent> value6 = new LinkedList<>();
 325                 value6.add(new DistributionNotificationEvent());
 326                 Mockito.when(value5.all()).thenReturn(value6);
 327                 Mockito.when(auditAccessor.getServiceDistributionNotify(Mockito.anyString())).thenReturn(value5);
 328
 329                 // default test
 330                 result = testSubject.getServiceDistributionStatusesList(serviceInstanceId);
 331         }
 332
 333         @Test
 334         public void testGetServiceDistributionStatusesListException3() throws Exception {
 335                 String serviceInstanceId = "";
 336                 Either<List<? extends AuditingGenericEvent>, ActionStatus> result;
 337
 338                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 339                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 340                 value2.add(new ResourceAdminEvent());
 341                 Mockito.when(value.all()).thenReturn(value2);
 342                 Mockito.when(auditAccessor.getServiceDistributionStatus(Mockito.anyString())).thenReturn(value);
 343
 344                 Result<DistributionDeployEvent> value3 = Mockito.mock(Result.class);
 345                 List<DistributionDeployEvent> value4 = new LinkedList<>();
 346                 value4.add(new DistributionDeployEvent());
 347                 Mockito.when(value3.all()).thenReturn(value4);
 348                 Mockito.when(auditAccessor.getServiceDistributionDeploy(Mockito.anyString())).thenReturn(value3);
 349
 350                 Mockito.when(auditAccessor.getServiceDistributionNotify(Mockito.anyString())).thenThrow(RuntimeException.class);
 351
 352                 // default test
 353                 result = testSubject.getServiceDistributionStatusesList(serviceInstanceId);
 354         }
 355
 356         @Test
 357         public void testGetServiceDistributionStatusesListException2() throws Exception {
 358                 String serviceInstanceId = "";
 359                 Either<List<? extends AuditingGenericEvent>, ActionStatus> result;
 360
 361                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 362                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 363                 value2.add(new ResourceAdminEvent());
 364                 Mockito.when(value.all()).thenReturn(value2);
 365                 Mockito.when(auditAccessor.getServiceDistributionStatus(Mockito.anyString())).thenReturn(value);
 366
 367                 Mockito.when(auditAccessor.getServiceDistributionDeploy(Mockito.anyString())).thenThrow(RuntimeException.class);
 368
 369                 // default test
 370                 result = testSubject.getServiceDistributionStatusesList(serviceInstanceId);
 371         }
 372
 373         @Test
 374         public void testGetServiceDistributionStatusesListException() throws Exception {
 375                 String serviceInstanceId = "";
 376                 Either<List<? extends AuditingGenericEvent>, ActionStatus> result;
 377
 378                 Mockito.when(auditAccessor.getServiceDistributionStatus(Mockito.anyString())).thenThrow(RuntimeException.class);
 379
 380                 // default test
 381                 result = testSubject.getServiceDistributionStatusesList(serviceInstanceId);
 382         }
 383
 384         @Test
 385         public void testGetServiceDistributionStatusesListNull() throws Exception {
 386                 String serviceInstanceId = "";
 387                 Either<List<? extends AuditingGenericEvent>, ActionStatus> result;
 388
 389                 // default test
 390                 result = testSubject.getServiceDistributionStatusesList(serviceInstanceId);
 391         }
 392
 393         @Test
 394         public void testGetAuditByServiceIdAndPrevVersionNull() throws Exception {
 395                 String serviceInstanceId = "";
 396                 String prevVersion = "";
 397                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 398
 399                 // default test
 400                 result = testSubject.getAuditByServiceIdAndPrevVersion(serviceInstanceId, prevVersion);
 401         }
 402
 403         @Test
 404         public void testGetAuditByServiceIdAndPrevVersion() throws Exception {
 405                 String serviceInstanceId = "";
 406                 String prevVersion = "";
 407                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 408
 409                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 410                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 411                 value2.add(new ResourceAdminEvent());
 412                 Mockito.when(value.all()).thenReturn(value2);
 413                 Mockito.when(auditAccessor.getAuditByServiceIdAndPrevVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(value);
 414
 415                 // default test
 416                 result = testSubject.getAuditByServiceIdAndPrevVersion(serviceInstanceId, prevVersion);
 417         }
 418
 419         @Test
 420         public void testGetAuditByServiceIdAndPrevVersionException() throws Exception {
 421                 String serviceInstanceId = "";
 422                 String prevVersion = "";
 423                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 424
 425                 Mockito.when(auditAccessor.getAuditByServiceIdAndPrevVersion(Mockito.anyString(), Mockito.anyString())).thenThrow(RuntimeException.class);
 426
 427                 // default test
 428                 result = testSubject.getAuditByServiceIdAndPrevVersion(serviceInstanceId, prevVersion);
 429         }
 430
 431         @Test
 432         public void testGetAuditByServiceIdAndCurrVersionNull() throws Exception {
 433                 String serviceInstanceId = "";
 434                 String currVersion = "";
 435                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 436
 437                 // default test
 438                 result = testSubject.getAuditByServiceIdAndCurrVersion(serviceInstanceId, currVersion);
 439         }
 440
 441         @Test
 442         public void testGetAuditByServiceIdAndCurrVersion() throws Exception {
 443                 String serviceInstanceId = "";
 444                 String currVersion = "";
 445                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 446
 447                 Result<ResourceAdminEvent> value = Mockito.mock(Result.class);
 448                 List<ResourceAdminEvent> value2 = new LinkedList<>();
 449                 value2.add(new ResourceAdminEvent());
 450                 Mockito.when(value.all()).thenReturn(value2);
 451                 Mockito.when(auditAccessor.getAuditByServiceIdAndCurrVersion(Mockito.anyString(), Mockito.anyString())).thenReturn(value);
 452
 453                 // default test
 454                 result = testSubject.getAuditByServiceIdAndCurrVersion(serviceInstanceId, currVersion);
 455         }
 456
 457         @Test
 458         public void testGetAuditByServiceIdAndCurrVersionException() throws Exception {
 459                 String serviceInstanceId = "";
 460                 String currVersion = "";
 461                 Either<List<ResourceAdminEvent>, ActionStatus> result;
 462
 463                 Mockito.when(auditAccessor.getAuditByServiceIdAndCurrVersion(Mockito.anyString(), Mockito.anyString())).thenThrow(RuntimeException.class);
 464
 465                 // default test
 466                 result = testSubject.getAuditByServiceIdAndCurrVersion(serviceInstanceId, currVersion);
 467         }
 468
 469         @Test
 470         public void testIsTableEmpty() throws Exception {
 471                 String tableName = "";
 472                 Either<Boolean, CassandraOperationStatus> result;
 473
 474                 // default test
 475                 result = testSubject.isTableEmpty(tableName);
 476         }
 477
 478         @Test
 479         public void testDeleteAllAudit() throws Exception {
 480                 CassandraOperationStatus result;
 481
 482                 // default test
 483                 result = testSubject.deleteAllAudit();
 484         }
 485 }