appc-inbound/appc-artifact-handler/provider/src/test/java/org/onap/appc/artifact/handler/ArtifactHandlerProviderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2019 Ericsson
   6  * ================================================================================
   7  * Modifications Copyright (C) 2019 IBM.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.appc.artifact.handler;
  25
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.util.concurrent.ExecutionException;
  29 import java.util.concurrent.Future;
  30
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.Mockito;
  34 import org.onap.appc.artifact.handler.utils.ArtifactHandlerProviderUtil;
  35 import org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants;
  36 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  37 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  38 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  39 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  40 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  41 import org.opendaylight.yang.gen.v1.org.onap.appc.artifacthandler.rev170321.ArtifactHandlerService;
  42 import org.opendaylight.yang.gen.v1.org.onap.appc.artifacthandler.rev170321.UploadartifactInput;
  43 import org.opendaylight.yang.gen.v1.org.onap.appc.artifacthandler.rev170321.UploadartifactInputBuilder;
  44 import org.opendaylight.yang.gen.v1.org.onap.appc.artifacthandler.rev170321.UploadartifactOutput;
  45 import org.opendaylight.yang.gen.v1.org.onap.appc.artifacthandler.rev170321.document.parameters.DocumentParameters;
  46 import org.opendaylight.yang.gen.v1.org.onap.appc.artifacthandler.rev170321.request.information.RequestInformation;
  47 import org.opendaylight.yangtools.yang.common.RpcResult;
  48
  49 import com.google.common.util.concurrent.CheckedFuture;
  50
  51 public class ArtifactHandlerProviderTest {
  52
  53     private DataBroker dataBroker = Mockito.mock(DataBroker.class);
  54     private RpcProviderRegistry rpcRegistry = Mockito.mock(RpcProviderRegistry.class);
  55     private NotificationPublishService notificationService = Mockito.mock(NotificationPublishService.class);
  56     private ReadWriteTransaction writeTransaction = Mockito.mock(ReadWriteTransaction.class);
  57     private CheckedFuture checkedFuture = Mockito.mock(CheckedFuture.class);
  58     private BindingAwareBroker.RpcRegistration<ArtifactHandlerService> rpcRegistration;
  59
  60     private ArtifactHandlerProvider artifactHandlerProvider;
  61
  62     @Before
  63     public void setup() {
  64         rpcRegistration =
  65                 (BindingAwareBroker.RpcRegistration<ArtifactHandlerService>) Mockito.mock(BindingAwareBroker.RpcRegistration.class);
  66         Mockito.doReturn(writeTransaction).when(dataBroker).newReadWriteTransaction();
  67         Mockito.doReturn(checkedFuture).when(writeTransaction).submit();
  68     }
  69
  70
  71     @Test
  72     public void testUploadArtifactNullInput() throws InterruptedException, ExecutionException {
  73         artifactHandlerProvider = new ArtifactHandlerProvider(dataBroker, notificationService, rpcRegistry);
  74         UploadartifactInput uploadArtifactInput = Mockito.mock(UploadartifactInput.class);
  75         Future<RpcResult<UploadartifactOutput>> output = (Future<RpcResult<UploadartifactOutput>>) artifactHandlerProvider.uploadartifact(uploadArtifactInput);
  76         assertTrue(output.get().getResult() instanceof UploadartifactOutput);
  77     }
  78
  79     @Test
  80     public void testUploadArtifactException() throws Exception {
  81         artifactHandlerProvider = Mockito.spy(new ArtifactHandlerProvider(dataBroker, notificationService, rpcRegistry));
  82         UploadartifactInputBuilder builder = new UploadartifactInputBuilder();
  83         DocumentParameters mockDocumentParameters = Mockito.mock(DocumentParameters.class);
  84         Mockito.doReturn("ARTIFACT CONTENTS").when(mockDocumentParameters).getArtifactContents();
  85         Mockito.doReturn("ARTIFACT NAME").when(mockDocumentParameters).getArtifactName();
  86         builder.setDocumentParameters(mockDocumentParameters);
  87         RequestInformation mockRequestInformation = Mockito.mock(RequestInformation.class);
  88         Mockito.doReturn("REQUEST ID").when(mockRequestInformation).getRequestId();
  89         Mockito.doReturn(SdcArtifactHandlerConstants.DESIGN_TOOL).when(mockRequestInformation).getSource();
  90         builder.setRequestInformation(mockRequestInformation);
  91         UploadartifactInput uploadArtifactInput = builder.build();
  92         ArtifactHandlerProviderUtil mockProvider = Mockito.mock(ArtifactHandlerProviderUtil.class);
  93         Mockito.doThrow(new Exception()).when(mockProvider).processTemplate(Mockito.anyString());
  94         Mockito.doReturn(mockProvider).when(artifactHandlerProvider).getArtifactHandlerProviderUtil(Mockito.any(UploadartifactInput.class));
  95         Future<RpcResult<UploadartifactOutput>> output = (Future<RpcResult<UploadartifactOutput>>) artifactHandlerProvider.uploadartifact(uploadArtifactInput);
  96         assertTrue(output.get().getResult() instanceof UploadartifactOutput);
  97     }
  98
  99     @Test
 100     public void testUploadArtifact() throws InterruptedException, ExecutionException {
 101         artifactHandlerProvider = Mockito.spy(new ArtifactHandlerProvider(dataBroker, notificationService, rpcRegistry));
 102         UploadartifactInputBuilder builder = new UploadartifactInputBuilder();
 103         DocumentParameters mockDocumentParameters = Mockito.mock(DocumentParameters.class);
 104         Mockito.doReturn("ARTIFACT CONTENTS").when(mockDocumentParameters).getArtifactContents();
 105         Mockito.doReturn("ARTIFACT NAME").when(mockDocumentParameters).getArtifactName();
 106         builder.setDocumentParameters(mockDocumentParameters);
 107         RequestInformation mockRequestInformation = Mockito.mock(RequestInformation.class);
 108         Mockito.doReturn("REQUEST ID").when(mockRequestInformation).getRequestId();
 109         Mockito.doReturn(SdcArtifactHandlerConstants.DESIGN_TOOL).when(mockRequestInformation).getSource();
 110         builder.setRequestInformation(mockRequestInformation);
 111         UploadartifactInput uploadArtifactInput = builder.build();
 112         ArtifactHandlerProviderUtil mockProvider = Mockito.mock(ArtifactHandlerProviderUtil.class);
 113         Mockito.doReturn(mockProvider).when(artifactHandlerProvider).getArtifactHandlerProviderUtil(Mockito.any(UploadartifactInput.class));
 114         Future<RpcResult<UploadartifactOutput>> output = (Future<RpcResult<UploadartifactOutput>>) artifactHandlerProvider.uploadartifact(uploadArtifactInput);
 115         assertTrue(output.get().getResult() instanceof UploadartifactOutput);
 116     }
 117
 118     @Test
 119     public void testUploadArtifact2() throws InterruptedException, ExecutionException {
 120         artifactHandlerProvider = Mockito.spy(new ArtifactHandlerProvider(dataBroker, notificationService, rpcRegistry));
 121         UploadartifactInputBuilder builder = new UploadartifactInputBuilder();
 122         DocumentParameters mockDocumentParameters = Mockito.mock(DocumentParameters.class);
 123         Mockito.doReturn("ARTIFACT CONTENTS").when(mockDocumentParameters).getArtifactContents();
 124         Mockito.doReturn("ARTIFACT NAME").when(mockDocumentParameters).getArtifactName();
 125         builder.setDocumentParameters(mockDocumentParameters);
 126         RequestInformation mockRequestInformation = Mockito.mock(RequestInformation.class);
 127         Mockito.doReturn("REQUEST ID").when(mockRequestInformation).getRequestId();
 128         builder.setRequestInformation(mockRequestInformation);
 129         UploadartifactInput uploadArtifactInput = builder.build();
 130         ArtifactHandlerProviderUtil mockProvider = Mockito.mock(ArtifactHandlerProviderUtil.class);
 131         Mockito.doReturn(mockProvider).when(artifactHandlerProvider).getArtifactHandlerProviderUtil(Mockito.any(UploadartifactInput.class));
 132         Future<RpcResult<UploadartifactOutput>> output = (Future<RpcResult<UploadartifactOutput>>) artifactHandlerProvider.uploadartifact(uploadArtifactInput);
 133         assertTrue(output.get().getResult() instanceof UploadartifactOutput);
 134     }
 135
 136     @Test
 137     public void testUploadArtifact3() throws InterruptedException, ExecutionException {
 138         artifactHandlerProvider = Mockito.spy(new ArtifactHandlerProvider(dataBroker, notificationService, rpcRegistry));
 139         UploadartifactInputBuilder builder = new UploadartifactInputBuilder();
 140         DocumentParameters mockDocumentParameters = Mockito.mock(DocumentParameters.class);
 141         Mockito.doReturn("ARTIFACT CONTENTS").when(mockDocumentParameters).getArtifactContents();
 142         Mockito.doReturn("ARTIFACT NAME").when(mockDocumentParameters).getArtifactName();
 143         builder.setDocumentParameters(mockDocumentParameters);
 144         RequestInformation mockRequestInformation = Mockito.mock(RequestInformation.class);
 145         Mockito.doReturn("REQUEST ID").when(mockRequestInformation).getRequestId();
 146         Mockito.doReturn(SdcArtifactHandlerConstants.ACTION).when(mockRequestInformation).getSource();
 147         builder.setRequestInformation(mockRequestInformation);
 148         UploadartifactInput uploadArtifactInput = builder.build();
 149         ArtifactHandlerProviderUtil mockProvider = Mockito.mock(ArtifactHandlerProviderUtil.class);
 150         Mockito.doReturn(mockProvider).when(artifactHandlerProvider).getArtifactHandlerProviderUtil(Mockito.any(UploadartifactInput.class));
 151         Future<RpcResult<UploadartifactOutput>> output = (Future<RpcResult<UploadartifactOutput>>) artifactHandlerProvider.uploadartifact(uploadArtifactInput);
 152         assertTrue(output.get().getResult() instanceof UploadartifactOutput);
 153     }
 154
 155     @Test
 156     public void testClose() throws Exception
 157     {
 158         artifactHandlerProvider = new ArtifactHandlerProvider(dataBroker, notificationService, rpcRegistry);
 159         artifactHandlerProvider.close();
 160     }
 161
 162     @Test
 163     public void testGetArtifactHandlerProviderUtil() throws Exception
 164     {
 165         artifactHandlerProvider = new ArtifactHandlerProvider(dataBroker, notificationService, rpcRegistry);
 166         UploadartifactInput uploadArtifactInput = Mockito.mock(UploadartifactInput.class);
 167         assertTrue(artifactHandlerProvider.getArtifactHandlerProviderUtil(uploadArtifactInput) instanceof ArtifactHandlerProviderUtil);
 168     }
 169
 170 }