catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/OperationalEnvironmentDaoTest.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.datatypes.enums.EnvironmentStatusEnum;
  15 import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry;
  16
  17 import java.util.List;
  18
  19 import static org.junit.Assert.assertTrue;
  20
  21 public class OperationalEnvironmentDaoTest {
  22
  23         @InjectMocks
  24         OperationalEnvironmentDao 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 testSave() throws Exception {
  68                 OperationalEnvironmentEntry operationalEnvironmentEntry = null;
  69                 CassandraOperationStatus result;
  70
  71                 // default test
  72                 result = testSubject.save(operationalEnvironmentEntry);
  73         }
  74
  75         @Test
  76         public void testGet() throws Exception {
  77                 String envId = "";
  78                 Either<OperationalEnvironmentEntry, CassandraOperationStatus> result;
  79
  80                 // default test
  81                 result = testSubject.get(envId);
  82         }
  83
  84         @Test
  85         public void testDelete() throws Exception {
  86                 String envId = "";
  87                 CassandraOperationStatus result;
  88
  89                 // default test
  90                 result = testSubject.delete(envId);
  91         }
  92
  93         @Test
  94         public void testDeleteAll() throws Exception {
  95                 CassandraOperationStatus result;
  96
  97                 // default test
  98                 result = testSubject.deleteAll();
  99
 100                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 101                 Session sessMock = Mockito.mock(Session.class);
 102                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 103                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 104                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 105                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 106                 testSubject.init();
 107
 108                 result = testSubject.deleteAll();
 109         }
 110
 111         @Test
 112         public void testIsTableEmpty() throws Exception {
 113                 String tableName = "";
 114                 Either<Boolean, CassandraOperationStatus> result;
 115
 116                 // default test
 117                 result = testSubject.isTableEmpty(tableName);
 118         }
 119
 120         @Test
 121         public void testGetByEnvironmentsStatus() throws Exception {
 122                 Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> result;
 123
 124                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 125                 Session sessMock = Mockito.mock(Session.class);
 126                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 127                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 128                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 129                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 130                 OperationalEnvironmentsAccessor value2 = Mockito.mock(OperationalEnvironmentsAccessor.class);
 131                 Mockito.when(mappMock.createAccessor(OperationalEnvironmentsAccessor.class)).thenReturn(value2);
 132                 Result<OperationalEnvironmentEntry> value3 = Mockito.mock(Result.class);
 133                 Mockito.when(value2.getByEnvironmentsStatus(Mockito.any(String.class))).thenReturn(value3);
 134                 testSubject.init();
 135
 136                 // default test
 137                 result = testSubject.getByEnvironmentsStatus(EnvironmentStatusEnum.COMPLETED);
 138         }
 139
 140         @Test
 141         public void testGetByEnvironmentsStatusNull() throws Exception {
 142                 Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> result;
 143
 144                 Mockito.when(clientMock.isConnected()).thenReturn(true);
 145                 Session sessMock = Mockito.mock(Session.class);
 146                 MappingManager mappMock = Mockito.mock(MappingManager.class);
 147                 ImmutablePair<Session, MappingManager> ipMock = ImmutablePair.of(sessMock, mappMock);
 148                 Either<ImmutablePair<Session, MappingManager>, CassandraOperationStatus> value = Either.left(ipMock);
 149                 Mockito.when(clientMock.connect(Mockito.any())).thenReturn(value);
 150                 OperationalEnvironmentsAccessor value2 = Mockito.mock(OperationalEnvironmentsAccessor.class);
 151                 Mockito.when(mappMock.createAccessor(OperationalEnvironmentsAccessor.class)).thenReturn(value2);
 152                 Result<OperationalEnvironmentEntry> value3 = null;
 153                 Mockito.when(value2.getByEnvironmentsStatus(Mockito.any(String.class))).thenReturn(value3);
 154                 testSubject.init();
 155
 156                 // default test
 157                 result = testSubject.getByEnvironmentsStatus(EnvironmentStatusEnum.COMPLETED);
 158         }
 159 }