servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/listeners/RendererListenerImplTest.java

   1 /*
   2  * Copyright © 2017 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.servicehandler.listeners;
   9
  10 import static org.mockito.ArgumentMatchers.any;
  11 import static org.mockito.Mockito.times;
  12 import static org.mockito.Mockito.verify;
  13 import static org.mockito.Mockito.verifyNoMoreInteractions;
  14 import static org.mockito.Mockito.verifyZeroInteractions;
  15
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.mockito.InjectMocks;
  19 import org.mockito.Mock;
  20 import org.mockito.Mockito;
  21 import org.mockito.MockitoAnnotations;
  22 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  23 import org.opendaylight.transportpce.common.OperationResult;
  24 import org.opendaylight.transportpce.pce.service.PathComputationService;
  25 import org.opendaylight.transportpce.servicehandler.ServiceInput;
  26 import org.opendaylight.transportpce.servicehandler.service.PCEServiceWrapper;
  27 import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
  28 import org.opendaylight.transportpce.servicehandler.utils.InjectField;
  29 import org.opendaylight.transportpce.servicehandler.utils.ServiceDataUtils;
  30 import org.opendaylight.transportpce.test.AbstractTest;
  31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceRpcResultSp;
  32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceRpcResultSpBuilder;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.ServiceNotificationTypes;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.State;
  35 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev171016.RpcStatusEx;
  36 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev171016.ServicePathNotificationTypes;
  37
  38 public class RendererListenerImplTest extends AbstractTest {
  39
  40     @InjectMocks
  41     private RendererListenerImpl rendererListenerImplMock;
  42     @Mock
  43     private PathComputationService pathComputationService;
  44     @Mock
  45     private NotificationPublishService notificationPublishService;
  46     @Mock
  47     private ServiceInput serviceInputMock;
  48     @Mock
  49     private ServiceDataStoreOperations serviceDataStoreOperationsMock;
  50     @Mock
  51     private PCEServiceWrapper pceServiceWrapperMock;
  52
  53     @Before
  54     public void init() {
  55         MockitoAnnotations.initMocks(this);
  56     }
  57
  58     @Test
  59     public void onServiceRpcResultServiceInputIsNull() {
  60         InjectField.inject(this.rendererListenerImplMock, "tempService", false);
  61         InjectField.inject(this.rendererListenerImplMock, "input", null);
  62         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
  63                 ServicePathNotificationTypes.ServiceDelete, "service 1", RpcStatusEx.Successful, "");
  64         Mockito.when(this.serviceDataStoreOperationsMock.deleteServicePath(notification.getServiceName()))
  65                 .thenReturn(OperationResult.ok("Successful"));
  66         Mockito.when(this.serviceDataStoreOperationsMock.deleteService(notification.getServiceName()))
  67                 .thenReturn(OperationResult.ok("Successful"));
  68         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
  69         verifyNoMoreInteractions(this.pceServiceWrapperMock);
  70     }
  71
  72     @Test
  73     public void onServiceRpcResultSIRSuccess() {
  74         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
  75                 ServicePathNotificationTypes.ServiceImplementationRequest, "service 1", RpcStatusEx.Successful, "");
  76         Mockito.when(this.serviceDataStoreOperationsMock.modifyService(notification.getServiceName(), State.InService,
  77                 State.InService))
  78                 .thenReturn(OperationResult.ok("Successful"));
  79         InjectField.inject(this.rendererListenerImplMock, "tempService", false);
  80         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
  81         verify(this.serviceDataStoreOperationsMock).modifyService(any(String.class), any(State.class),
  82                 any(State.class));
  83     }
  84
  85     @Test
  86     public void onServiceRpcResultSIRTempSuccess() {
  87         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
  88                 ServicePathNotificationTypes.ServiceImplementationRequest, "service 1", RpcStatusEx.Successful, "");
  89         Mockito.when(this.serviceDataStoreOperationsMock.modifyTempService(notification.getServiceName(),
  90                 State.InService, State.InService)).thenReturn(OperationResult.ok("Successful"));
  91         InjectField.inject(this.rendererListenerImplMock, "tempService", true);
  92         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
  93         verify(this.serviceDataStoreOperationsMock).modifyTempService(any(String.class), any(State.class),
  94                 any(State.class));
  95     }
  96
  97     @Test
  98     public void onServiceRpcResultSIRFailed() {
  99         InjectField.inject(this.rendererListenerImplMock, "tempService", false);
 100         Mockito.when(this.serviceDataStoreOperationsMock.deleteServicePath(any(String.class)))
 101                 .thenReturn(OperationResult.ok("Successful"));
 102         Mockito.when(this.serviceDataStoreOperationsMock.deleteService(any(String.class)))
 103                 .thenReturn(OperationResult.ok("Successful"));
 104         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
 105                 ServicePathNotificationTypes.ServiceImplementationRequest, "service 1", RpcStatusEx.Failed, "");
 106         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 107         verify(this.serviceDataStoreOperationsMock).deleteServicePath(any(String.class));
 108         verify(this.serviceDataStoreOperationsMock).deleteService(any(String.class));
 109     }
 110
 111     @Test
 112     public void onServiceRpcResultSIRTempFailed() {
 113         InjectField.inject(this.rendererListenerImplMock, "tempService", true);
 114         Mockito.when(this.serviceDataStoreOperationsMock.deleteServicePath(any(String.class)))
 115                 .thenReturn(OperationResult.ok("Successful"));
 116         Mockito.when(this.serviceDataStoreOperationsMock.deleteTempService(any(String.class)))
 117                 .thenReturn(OperationResult.ok("Successful"));
 118         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
 119                 ServicePathNotificationTypes.ServiceImplementationRequest, "service 1", RpcStatusEx.Failed, "");
 120         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 121         verify(this.serviceDataStoreOperationsMock).deleteServicePath(any(String.class));
 122         verify(this.serviceDataStoreOperationsMock).deleteTempService(any(String.class));
 123     }
 124
 125     @Test
 126     public void onServiceRpcResultSDSuccess() {
 127         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
 128                 ServicePathNotificationTypes.ServiceDelete, "service 1", RpcStatusEx.Successful, "");
 129         Mockito.when(this.serviceInputMock.getServiceName()).thenReturn(notification.getServiceName());
 130         Mockito.when(this.pceServiceWrapperMock.cancelPCEResource(notification.getServiceName(),
 131                 ServiceNotificationTypes.ServiceDeleteResult)).thenReturn(null);
 132         InjectField.inject(this.rendererListenerImplMock, "tempService", false);
 133         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 134         verify(this.pceServiceWrapperMock).cancelPCEResource(any(String.class), any(ServiceNotificationTypes.class));
 135     }
 136
 137     @Test
 138     public void onServiceRpcResultSDTempSuccess() {
 139         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
 140                 ServicePathNotificationTypes.ServiceDelete, "service 1", RpcStatusEx.Successful, "");
 141         Mockito.when(this.serviceInputMock.getServiceName()).thenReturn(notification.getServiceName());
 142         Mockito.when(this.pceServiceWrapperMock.cancelPCEResource(notification.getServiceName(),
 143                 ServiceNotificationTypes.ServiceDeleteResult)).thenReturn(null);
 144         InjectField.inject(this.rendererListenerImplMock, "tempService", true);
 145         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 146         verify(this.pceServiceWrapperMock).cancelPCEResource(any(String.class), any(ServiceNotificationTypes.class));
 147     }
 148
 149     @Test
 150     public void onServiceRpcResultSDFailed() {
 151         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
 152                 ServicePathNotificationTypes.ServiceDelete, "service 1", RpcStatusEx.Failed, "");
 153         InjectField.inject(this.rendererListenerImplMock, "tempService", true);
 154         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 155         verifyZeroInteractions(this.pceServiceWrapperMock);
 156     }
 157
 158     @Test
 159     public void onServiceRpcResultSDTempFailed() {
 160         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp(
 161                 ServicePathNotificationTypes.ServiceDelete, "service 1", RpcStatusEx.Failed, "");
 162         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 163         verifyZeroInteractions(this.pceServiceWrapperMock);
 164     }
 165
 166     @Test
 167     public void onServiceRpcResultSpRepeat() {
 168         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp();
 169         Mockito.when(this.serviceDataStoreOperationsMock.modifyService(notification.getServiceName(), State.InService,
 170                 State.InService))
 171                 .thenReturn(OperationResult.ok("Successful"));
 172         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 173         verify(this.serviceDataStoreOperationsMock).modifyService(any(String.class), any(State.class),
 174                 any(State.class));
 175         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 176         verifyZeroInteractions(this.serviceDataStoreOperationsMock);
 177     }
 178
 179     @Test
 180     public void onServiceRpcResultSpFailed() {
 181         ServiceRpcResultSp notification = ServiceDataUtils.buildFailedServiceRpcResultSp();
 182         Mockito.when(this.serviceDataStoreOperationsMock.deleteServicePath(any(String.class)))
 183                 .thenReturn(OperationResult.ok("Successful"));
 184         Mockito.when(this.serviceDataStoreOperationsMock.deleteService(any(String.class)))
 185                 .thenReturn(OperationResult.ok("Successful"));
 186         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 187         verify(this.serviceDataStoreOperationsMock).deleteServicePath(any(String.class));
 188         verify(this.serviceDataStoreOperationsMock).deleteService(any(String.class));
 189     }
 190
 191     @Test
 192     public void onServiceRpcResultSpRepeatFailedCompareCase1() {
 193         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp();
 194         Mockito.when(this.serviceDataStoreOperationsMock.modifyService(notification.getServiceName(), State.InService,
 195                 State.InService)).thenReturn(OperationResult.ok("Successful"));
 196         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 197         verify(this.serviceDataStoreOperationsMock).modifyService(any(String.class), any(State.class),
 198                 any(State.class));
 199         ServiceRpcResultSp notification2 = new ServiceRpcResultSpBuilder(notification)
 200                 .setNotificationType(ServicePathNotificationTypes.ServiceDelete).build();
 201         Mockito.when(this.serviceInputMock.getServiceName()).thenReturn(notification.getServiceName());
 202         Mockito.when(this.pceServiceWrapperMock.cancelPCEResource(notification.getServiceName(),
 203                 ServiceNotificationTypes.ServiceDeleteResult)).thenReturn(null);
 204         this.rendererListenerImplMock.onServiceRpcResultSp(notification2);
 205         verify(this.pceServiceWrapperMock).cancelPCEResource(any(String.class), any(ServiceNotificationTypes.class));
 206     }
 207
 208     @Test
 209     public void onServiceRpcResultSpRepeatFailedCompareCase2() {
 210         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp();
 211         Mockito.when(this.serviceDataStoreOperationsMock.modifyService(notification.getServiceName(), State.InService,
 212                 State.InService)).thenReturn(OperationResult.ok("Successful"));
 213         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 214         ServiceRpcResultSp notification2 =
 215                 new ServiceRpcResultSpBuilder(notification).setServiceName("service 2").build();
 216         Mockito.when(this.serviceDataStoreOperationsMock.modifyService(notification2.getServiceName(), State.InService,
 217                 State.InService)).thenReturn(OperationResult.ok("Successful"));
 218         this.rendererListenerImplMock.onServiceRpcResultSp(notification2);
 219         verify(this.serviceDataStoreOperationsMock, times(2)).modifyService(any(String.class), any(State.class),
 220                   any(State.class));
 221     }
 222
 223     @Test
 224     public void onServiceRpcResultSpRepeatFailedCompareCase3() {
 225         ServiceRpcResultSp notification = ServiceDataUtils.buildServiceRpcResultSp();
 226         Mockito.when(this.serviceDataStoreOperationsMock.modifyService(notification.getServiceName(), State.InService,
 227                 State.InService)).thenReturn(OperationResult.ok("Successful"));
 228         this.rendererListenerImplMock.onServiceRpcResultSp(notification);
 229         verify(this.serviceDataStoreOperationsMock).modifyService(any(String.class), any(State.class),
 230                 any(State.class));
 231         ServiceRpcResultSp notification2 =
 232                 new ServiceRpcResultSpBuilder(notification).setStatus(RpcStatusEx.Failed).build();
 233         Mockito.when(this.serviceDataStoreOperationsMock.deleteServicePath(any(String.class)))
 234                 .thenReturn(OperationResult.ok("Successful"));
 235         Mockito.when(this.serviceDataStoreOperationsMock.deleteService(any(String.class)))
 236                 .thenReturn(OperationResult.ok("Successful"));
 237         this.rendererListenerImplMock.onServiceRpcResultSp(notification2);
 238         verify(this.serviceDataStoreOperationsMock).deleteServicePath(any(String.class));
 239         verify(this.serviceDataStoreOperationsMock).deleteService(any(String.class));
 240     }
 241
 242 }