catalog-model/src/test/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCacheTest.java

   1 package org.openecomp.sdc.be.model.cache;
   2
   3 import fj.data.Either;
   4 import mockit.Deencapsulation;
   5 import org.apache.commons.lang3.tuple.ImmutablePair;
   6 import org.junit.Before;
   7 import org.junit.Test;
   8 import org.mockito.InjectMocks;
   9 import org.mockito.Mock;
  10 import org.mockito.Mockito;
  11 import org.mockito.MockitoAnnotations;
  12 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  13 import org.openecomp.sdc.be.model.DataTypeDefinition;
  14 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  15 import org.openecomp.sdc.be.resources.data.DataTypeData;
  16 import org.openecomp.sdc.be.unittests.utils.ModelConfDependentTest;
  17
  18 import java.util.HashMap;
  19 import java.util.LinkedList;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 public class ApplicationDataTypeCacheTest extends ModelConfDependentTest{
  24
  25         @InjectMocks
  26         private ApplicationDataTypeCache testSubject;
  27
  28         @Mock
  29         PropertyOperation propertyOperation;
  30
  31         @Before
  32         public void setUpMocks() throws Exception {
  33                 MockitoAnnotations.initMocks(this);
  34         }
  35
  36
  37         @Test
  38         public void testInit() throws Exception {
  39                 testSubject.init();
  40         }
  41
  42         @Test
  43         public void testDestroy() throws Exception {
  44                 testSubject.init();
  45                 Deencapsulation.invoke(testSubject, "destroy");
  46         }
  47
  48         @Test
  49         public void testShutdownExecutor() throws Exception {
  50
  51                 // default test
  52                 Deencapsulation.invoke(testSubject, "shutdownExecutor");
  53         }
  54
  55         @Test
  56         public void testGetAllDataTypesFromGraph() throws Exception {
  57                 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> result;
  58
  59                 // default test
  60                 result = Deencapsulation.invoke(testSubject, "getAllDataTypesFromGraph");
  61         }
  62
  63         @Test
  64         public void testGetAll() throws Exception {
  65                 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> result;
  66
  67                 // default test
  68                 result = testSubject.getAll();
  69         }
  70
  71         @Test
  72         public void testGet() throws Exception {
  73                 String uniqueId = "";
  74                 Either<DataTypeDefinition, JanusGraphOperationStatus> result;
  75
  76                 // default test
  77                 result = testSubject.get(uniqueId);
  78         }
  79
  80         @Test
  81         public void testGet2() throws Exception {
  82                 String uniqueId = "";
  83                 Either<DataTypeDefinition, JanusGraphOperationStatus> result;
  84
  85                 HashMap<String, DataTypeDefinition> a = new HashMap<>();
  86                 DataTypeDefinition value1 = new DataTypeDefinition();
  87                 value1.setUniqueId("mock");
  88                 a.put("mock", value1);
  89                 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> value = Either.left(a);
  90                 Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value);
  91                 // default test
  92                 Deencapsulation.invoke(testSubject, "replaceAllData");
  93                 result = testSubject.get(uniqueId);
  94         }
  95
  96         @Test
  97         public void testRun() throws Exception {
  98                 testSubject.run();
  99         }
 100
 101         @Test
 102         public void testRun2() throws Exception {
 103                 Either<List<DataTypeData>, JanusGraphOperationStatus> value = Either.right(
 104         JanusGraphOperationStatus.GENERAL_ERROR);
 105                 Mockito.when(propertyOperation.getAllDataTypeNodes()).thenReturn(value);
 106                 testSubject.run();
 107         }
 108
 109         @Test
 110         public void testRun3() throws Exception {
 111                 LinkedList<DataTypeData> a = new LinkedList<>();
 112                 a.add(new DataTypeData());
 113                 Either<List<DataTypeData>, JanusGraphOperationStatus> value = Either.left(a);
 114                 Mockito.when(propertyOperation.getAllDataTypeNodes()).thenReturn(value);
 115
 116                 HashMap<String, DataTypeDefinition> a1 = new HashMap<>();
 117                 DataTypeDefinition value1 = new DataTypeDefinition();
 118                 value1.setUniqueId("mock");
 119                 a1.put("mock", value1);
 120                 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> value2 = Either.left(a1);
 121                 Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value2);
 122
 123                 Deencapsulation.invoke(testSubject, "replaceAllData");
 124                 testSubject.run();
 125         }
 126
 127         @Test
 128         public void testCompareDataTypes() throws Exception {
 129                 Map<String, ImmutablePair<Long, Long>> dataTypeNameToModificationTime = new HashMap<>();
 130                 Map<String, ImmutablePair<Long, Long>> currentDataTypeToModificationTime = new HashMap<>();
 131                 boolean result;
 132
 133                 // default test
 134                 result = Deencapsulation.invoke(testSubject, "compareDataTypes", dataTypeNameToModificationTime, currentDataTypeToModificationTime);
 135         }
 136
 137         @Test
 138         public void testCompareDataTypes2() throws Exception {
 139                 Map<String, ImmutablePair<Long, Long>> dataTypeNameToModificationTime = new HashMap<>();
 140                 Map<String, ImmutablePair<Long, Long>> currentDataTypeToModificationTime = new HashMap<>();
 141                 boolean result;
 142
 143                 currentDataTypeToModificationTime.put("mock", ImmutablePair.of(1L, 2L));
 144                 dataTypeNameToModificationTime.put("mock", ImmutablePair.of(5L, 6L));
 145
 146                 // default test
 147                 result = Deencapsulation.invoke(testSubject, "compareDataTypes", dataTypeNameToModificationTime, currentDataTypeToModificationTime);
 148         }
 149
 150         @Test
 151         public void testReplaceAllData() throws Exception {
 152                 HashMap<String, DataTypeDefinition> a = new HashMap<>();
 153                 DataTypeDefinition value1 = new DataTypeDefinition();
 154                 value1.setUniqueId("mock");
 155                 a.put("mock", value1);
 156                 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> value = Either.left(a);
 157                 Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value);
 158                 // default test
 159                 Deencapsulation.invoke(testSubject, "replaceAllData");
 160         }
 161
 162         @Test
 163         public void testReplaceAllData2() throws Exception {
 164                 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> value = Either.right(
 165         JanusGraphOperationStatus.GENERAL_ERROR);
 166                 Mockito.when(propertyOperation.getAllDataTypes()).thenReturn(value);
 167                 // default test
 168                 Deencapsulation.invoke(testSubject, "replaceAllData");
 169         }
 170 }