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

   1 package org.openecomp.sdc.be.model.cache.jobs;
   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.Mock;
   9 import org.mockito.Mockito;
  10 import org.mockito.MockitoAnnotations;
  11 import org.openecomp.sdc.be.dao.api.ActionStatus;
  12 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  13 import org.openecomp.sdc.be.model.Component;
  14 import org.openecomp.sdc.be.model.Resource;
  15 import org.openecomp.sdc.be.model.cache.ComponentCache;
  16 import org.openecomp.sdc.be.model.cache.DaoInfo;
  17 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  18 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  19 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
  20 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  21
  22 import java.util.function.Function;
  23
  24 public class CheckAndUpdateJobTest {
  25
  26         CheckAndUpdateJob testSubject;
  27
  28         @Mock
  29         DaoInfo daoInfo;
  30
  31         @Before
  32         public void setUp() throws Exception {
  33                 MockitoAnnotations.initMocks(this);
  34
  35                 testSubject = new CheckAndUpdateJob(daoInfo, "mock", NodeTypeEnum.Resource, 0L);
  36         }
  37
  38         @Test
  39         public void testDoWorkException() throws Exception {
  40                 Object result;
  41
  42                 // default test
  43                 ToscaOperationFacade answer = Mockito.mock(ToscaOperationFacade.class);
  44                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer);
  45
  46                 result = testSubject.doWork();
  47         }
  48
  49         @Test
  50         public void testDoWorkFalse() throws Exception {
  51                 Object result;
  52
  53                 // default test
  54                 ComponentCache answer = Mockito.mock(ComponentCache.class);
  55                 Mockito.when(answer.getComponentAndTime(Mockito.anyString(), Mockito.any(Function.class)))
  56                                 .thenReturn(Either.right(ActionStatus.ACCEPTED));
  57                 Mockito.when(daoInfo.getComponentCache()).thenReturn(answer);
  58                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
  59                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
  60
  61                 result = testSubject.doWork();
  62         }
  63
  64         @Test
  65         public void testDoWorkResourceNotFound() throws Exception {
  66                 Object result;
  67
  68                 // default test
  69                 ComponentCache answer = Mockito.mock(ComponentCache.class);
  70                 Either<ImmutablePair<Component, Long>, ActionStatus> value;
  71                 Mockito.when(answer.getComponentAndTime(Mockito.anyString(), Mockito.any(Function.class)))
  72                                 .thenReturn(Either.right(ActionStatus.RESOURCE_NOT_FOUND));
  73                 Mockito.when(daoInfo.getComponentCache()).thenReturn(answer);
  74                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
  75                 Mockito.when(answer1.getComponentMetadata(Mockito.anyString()))
  76                                 .thenReturn(Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND));
  77                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
  78
  79                 result = testSubject.doWork();
  80         }
  81
  82         @Test
  83         public void testDoWork() throws Exception {
  84                 Object result;
  85
  86                 // default test
  87                 ComponentCache answer = Mockito.mock(ComponentCache.class);
  88                 ImmutablePair<Component, Long> value = ImmutablePair.of(new Resource(), 0L);
  89                 Mockito.when(answer.getComponentAndTime(Mockito.anyString(), Mockito.any(Function.class)))
  90                                 .thenReturn(Either.left(value));
  91                 Mockito.when(daoInfo.getComponentCache()).thenReturn(answer);
  92                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
  93                 Mockito.when(answer1.getComponentMetadata(Mockito.anyString()))
  94                                 .thenReturn(Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND));
  95                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
  96
  97                 result = testSubject.doWork();
  98         }
  99
 100         @Test
 101         public void testDoWork1() throws Exception {
 102                 Object result;
 103
 104                 // default test
 105                 ComponentCache answer = Mockito.mock(ComponentCache.class);
 106                 ImmutablePair<Component, Long> value = ImmutablePair.of(new Resource(), 1L);
 107                 Mockito.when(answer.getComponentAndTime(Mockito.anyString(), Mockito.any(Function.class)))
 108                                 .thenReturn(Either.left(value));
 109                 Mockito.when(daoInfo.getComponentCache()).thenReturn(answer);
 110                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
 111                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
 112
 113                 result = testSubject.doWork();
 114         }
 115
 116         @Test
 117         public void testUpdateCache() throws Exception {
 118                 String componentId = "mock";
 119                 NodeTypeEnum nodeTypeEnum = null;
 120                 Long timestamp = null;
 121                 boolean result;
 122
 123                 // default test
 124                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
 125                 ComponentMetadataData a = new ResourceMetadataData();
 126                 a.getMetadataDataDefinition().setLastUpdateDate(0L);
 127                 Mockito.when(answer1.getComponentMetadata(Mockito.anyString()))
 128                                 .thenReturn(Either.left(a));
 129                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
 130
 131                 Mockito.when(answer1.getToscaElement(Mockito.anyString())).thenReturn(Either.left(new Resource()));
 132                 ComponentCache compCache = Mockito.mock(ComponentCache.class);
 133                 Mockito.when(compCache.setComponent(Mockito.any(), Mockito.any())).thenReturn(true);
 134                 Mockito.when(daoInfo.getComponentCache()).thenReturn(compCache);
 135
 136                 result = Deencapsulation.invoke(testSubject, "updateCache", componentId, NodeTypeEnum.Resource, 0L);
 137         }
 138
 139         @Test
 140         public void testUpdateCacheFailedToUpdateCache() throws Exception {
 141                 String componentId = "mock";
 142                 NodeTypeEnum nodeTypeEnum = null;
 143                 Long timestamp = null;
 144                 boolean result;
 145
 146                 // default test
 147                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
 148                 ComponentMetadataData a = new ResourceMetadataData();
 149                 a.getMetadataDataDefinition().setLastUpdateDate(0L);
 150                 Mockito.when(answer1.getComponentMetadata(Mockito.anyString()))
 151                                 .thenReturn(Either.left(a));
 152                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
 153
 154                 Mockito.when(answer1.getToscaElement(Mockito.anyString())).thenReturn(Either.left(new Resource()));
 155                 ComponentCache compCache = Mockito.mock(ComponentCache.class);
 156                 Mockito.when(daoInfo.getComponentCache()).thenReturn(compCache);
 157
 158                 result = Deencapsulation.invoke(testSubject, "updateCache", componentId, NodeTypeEnum.Resource, 0L);
 159         }
 160
 161         @Test
 162         public void testUpdateCacheToscaElemntNotFound() throws Exception {
 163                 String componentId = "mock";
 164                 NodeTypeEnum nodeTypeEnum = null;
 165                 Long timestamp = null;
 166                 boolean result;
 167
 168                 // default test
 169                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
 170                 ComponentMetadataData a = new ResourceMetadataData();
 171                 a.getMetadataDataDefinition().setLastUpdateDate(0L);
 172                 Mockito.when(answer1.getComponentMetadata(Mockito.anyString()))
 173                                 .thenReturn(Either.left(a));
 174                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
 175
 176                 Mockito.when(answer1.getToscaElement(Mockito.anyString())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 177
 178                 result = Deencapsulation.invoke(testSubject, "updateCache", componentId, NodeTypeEnum.Resource, 0L);
 179         }
 180
 181         @Test
 182         public void testUpdateCacheNotUpdatedTimestamp() throws Exception {
 183                 String componentId = "mock";
 184                 NodeTypeEnum nodeTypeEnum = null;
 185                 Long timestamp = null;
 186                 boolean result;
 187
 188                 // default test
 189                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
 190                 ComponentMetadataData a = new ResourceMetadataData();
 191                 a.getMetadataDataDefinition().setLastUpdateDate(1L);
 192                 Mockito.when(answer1.getComponentMetadata(Mockito.anyString()))
 193                                 .thenReturn(Either.left(a));
 194                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
 195
 196                 result = Deencapsulation.invoke(testSubject, "updateCache", componentId, NodeTypeEnum.Resource, 0L);
 197         }
 198
 199         @Test
 200         public void testUpdateCacheNotFound() throws Exception {
 201                 String componentId = "mock";
 202                 NodeTypeEnum nodeTypeEnum = null;
 203                 Long timestamp = null;
 204                 boolean result;
 205
 206                 // default test
 207                 ToscaOperationFacade answer1 = Mockito.mock(ToscaOperationFacade.class);
 208                 Mockito.when(answer1.getComponentMetadata(Mockito.anyString()))
 209                                 .thenReturn(Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND));
 210                 Mockito.when(daoInfo.getToscaOperationFacade()).thenReturn(answer1);
 211
 212                 result = Deencapsulation.invoke(testSubject, "updateCache", componentId, NodeTypeEnum.Resource, 0L);
 213         }
 214 }