gerrit.onap Code Review - dcaegen2/services.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * BBS-RELOCATION-CPE-AUTHENTICATION-HANDLER
   4  * ================================================================================
   5  * Copyright (C) 2019 NOKIA Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.bbs.event.processor.pipelines;
  22
  23 import static org.junit.jupiter.api.Assertions.assertAll;
  24 import static org.junit.jupiter.api.Assertions.assertEquals;
  25 import static org.junit.jupiter.api.Assertions.assertFalse;
  26 import static org.junit.jupiter.api.Assertions.assertTrue;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.Mockito.when;
  29
  30 import java.time.Duration;
  31 import java.time.Instant;
  32 import java.util.concurrent.ScheduledFuture;
  33
  34 import org.junit.jupiter.api.DisplayName;
  35 import org.junit.jupiter.api.Test;
  36 import org.mockito.Mockito;
  37 import org.onap.bbs.event.processor.config.ApplicationConfiguration;
  38 import org.onap.bbs.event.processor.config.ConsulConfigurationGateway;
  39 import org.springframework.scheduling.TaskScheduler;
  40
  41 // We can safely suppress unchecked assignment warnings for the ScheduledFuture mock
  42 @SuppressWarnings("unchecked")
  43 @DisplayName("Application Task Scheduler Unit-Tests")
  44 class SchedulerTest {
  45
  46     private Scheduler applicationScheduler;
  47     private ApplicationConfiguration configuration;
  48     private TaskScheduler taskScheduler;
  49
  50     SchedulerTest() {
  51         configuration = Mockito.mock(ApplicationConfiguration.class);
  52         taskScheduler = Mockito.mock(TaskScheduler.class);
  53         ReRegistrationPipeline reRegistrationPipeline = Mockito.mock(ReRegistrationPipeline.class);
  54         CpeAuthenticationPipeline cpeAuthenticationPipeline = Mockito.mock(CpeAuthenticationPipeline.class);
  55         ConsulConfigurationGateway configurationGateway = Mockito.mock(ConsulConfigurationGateway.class);
  56         this.applicationScheduler = new Scheduler(configuration, configurationGateway, taskScheduler,
  57                 reRegistrationPipeline, cpeAuthenticationPipeline);
  58     }
  59
  60     @Test
  61     void scheduleTasksWithValidSchedulingPeriod_Succeeds() {
  62         when(configuration.getPipelinesPollingIntervalInSeconds()).thenReturn(20);
  63         ScheduledFuture scheduledFuture = Mockito.mock(ScheduledFuture.class);
  64         when(taskScheduler.scheduleAtFixedRate(any(Runnable.class), any(Instant.class), any(Duration.class)))
  65                .thenReturn(scheduledFuture);
  66
  67         applicationScheduler.setupScheduler();
  68         assertAll("Scheduler with valid Scheduling period",
  69             () -> assertEquals(2, applicationScheduler.numberOfTotalTasks(), "Total tasks"),
  70             () -> assertEquals(2, applicationScheduler.numberOfActiveTasks(), "Active tasks"),
  71             () -> assertEquals(0, applicationScheduler.numberOfCancelledTasks(), "Cancelled tasks")
  72         );
  73     }
  74
  75     @Test
  76     void cancellingRunningTasksSucceeds_tasksAreDeleted() {
  77         when(configuration.getPipelinesPollingIntervalInSeconds()).thenReturn(20);
  78         ScheduledFuture scheduledFuture1 = Mockito.mock(ScheduledFuture.class);
  79         ScheduledFuture scheduledFuture2 = Mockito.mock(ScheduledFuture.class);
  80         when(scheduledFuture1.cancel(false)).thenReturn(true);
  81         when(scheduledFuture2.cancel(false)).thenReturn(true);
  82         when(scheduledFuture1.isCancelled()).thenReturn(true);
  83         when(scheduledFuture2.isCancelled()).thenReturn(true);
  84         when(taskScheduler.scheduleAtFixedRate(any(Runnable.class), any(Instant.class), any(Duration.class)))
  85                 .thenReturn(scheduledFuture1).thenReturn(scheduledFuture2);
  86
  87         applicationScheduler.setupScheduler();
  88         boolean result = applicationScheduler.cancelScheduledProcessingTasks();
  89         assertAll("Successfully cancelling tasks",
  90             () -> assertTrue(result, "Result of cancellation task"),
  91             () -> assertEquals(0, applicationScheduler.numberOfTotalTasks(), "Total tasks"),
  92             () -> assertEquals(0, applicationScheduler.numberOfActiveTasks(), "Active tasks"),
  93             () -> assertEquals(0, applicationScheduler.numberOfCancelledTasks(), "Cancelled tasks")
  94         );
  95     }
  96
  97     @Test
  98     void cancellingRunningTasksPartiallyFailing_tasksAreNotDeleted() {
  99         when(configuration.getPipelinesPollingIntervalInSeconds()).thenReturn(20);
 100         ScheduledFuture scheduledFuture1 = Mockito.mock(ScheduledFuture.class);
 101         ScheduledFuture scheduledFuture2 = Mockito.mock(ScheduledFuture.class);
 102         when(scheduledFuture1.cancel(false)).thenReturn(true);
 103         when(scheduledFuture2.cancel(false)).thenReturn(false);
 104         when(scheduledFuture1.isCancelled()).thenReturn(true);
 105         when(scheduledFuture2.isCancelled()).thenReturn(false);
 106         when(taskScheduler.scheduleAtFixedRate(any(Runnable.class), any(Instant.class), any(Duration.class)))
 107                 .thenReturn(scheduledFuture1).thenReturn(scheduledFuture2);
 108
 109         applicationScheduler.setupScheduler();
 110         boolean result = applicationScheduler.cancelScheduledProcessingTasks();
 111         assertAll("Partially cancelling tasks",
 112             () -> assertFalse(result, "Result of cancellation task"),
 113             () -> assertEquals(1, applicationScheduler.numberOfTotalTasks(), "Total tasks"),
 114             () -> assertEquals(1, applicationScheduler.numberOfActiveTasks(), "Active tasks"),
 115             () -> assertEquals(0, applicationScheduler.numberOfCancelledTasks(), "Cancelled tasks")
 116         );
 117     }
 118
 119     @Test
 120     void cancellingRunningTasksFailingForAllOfThem_noTasksAreDeleted() {
 121         when(configuration.getPipelinesPollingIntervalInSeconds()).thenReturn(20);
 122         ScheduledFuture scheduledFuture1 = Mockito.mock(ScheduledFuture.class);
 123         ScheduledFuture scheduledFuture2 = Mockito.mock(ScheduledFuture.class);
 124         when(scheduledFuture1.cancel(false)).thenReturn(false);
 125         when(scheduledFuture2.cancel(false)).thenReturn(false);
 126         when(scheduledFuture1.isCancelled()).thenReturn(false);
 127         when(scheduledFuture2.isCancelled()).thenReturn(false);
 128         when(taskScheduler.scheduleAtFixedRate(any(Runnable.class), any(Instant.class), any(Duration.class)))
 129                 .thenReturn(scheduledFuture1).thenReturn(scheduledFuture2);
 130
 131         applicationScheduler.setupScheduler();
 132         boolean result = applicationScheduler.cancelScheduledProcessingTasks();
 133         assertAll("Failing in cancelling tasks",
 134             () -> assertFalse(result, "Result of cancellation task"),
 135             () -> assertEquals(2, applicationScheduler.numberOfTotalTasks(), "Total tasks"),
 136             () -> assertEquals(2, applicationScheduler.numberOfActiveTasks(), "Active tasks"),
 137             () -> assertEquals(0, applicationScheduler.numberOfCancelledTasks(), "Cancelled tasks")
 138         );
 139     }
 140
 141     @Test
 142     void reSchedulingWithExistingActiveTasks_Fails() {
 143         when(configuration.getPipelinesPollingIntervalInSeconds()).thenReturn(20);
 144         ScheduledFuture scheduledFuture1 = Mockito.mock(ScheduledFuture.class);
 145         ScheduledFuture scheduledFuture2 = Mockito.mock(ScheduledFuture.class);
 146         when(scheduledFuture1.isCancelled()).thenReturn(false);
 147         when(scheduledFuture2.isCancelled()).thenReturn(false);
 148         when(taskScheduler.scheduleAtFixedRate(any(Runnable.class), any(Instant.class), any(Duration.class)))
 149                 .thenReturn(scheduledFuture1).thenReturn(scheduledFuture2);
 150
 151         applicationScheduler.setupScheduler();
 152         boolean result = applicationScheduler.reScheduleProcessingTasks();
 153         assertAll("Rescheduling with active tasks",
 154             () -> assertFalse(result, "Result of re-scheduling"),
 155             () -> assertEquals(2, applicationScheduler.numberOfTotalTasks(), "Total tasks"),
 156             () -> assertEquals(2, applicationScheduler.numberOfActiveTasks(), "Active tasks"),
 157             () -> assertEquals(0, applicationScheduler.numberOfCancelledTasks(), "Cancelled tasks")
 158         );
 159     }
 160
 161     @Test
 162     void reSchedulingWithExistingCancelledTasks_Succeeds() {
 163         when(configuration.getPipelinesPollingIntervalInSeconds()).thenReturn(20);
 164         // Initial tasks
 165         ScheduledFuture scheduledFuture1 = Mockito.mock(ScheduledFuture.class);
 166         ScheduledFuture scheduledFuture2 = Mockito.mock(ScheduledFuture.class);
 167         // Re-scheduled tasks
 168         ScheduledFuture scheduledFuture3 = Mockito.mock(ScheduledFuture.class);
 169         ScheduledFuture scheduledFuture4 = Mockito.mock(ScheduledFuture.class);
 170         when(scheduledFuture1.isCancelled()).thenReturn(true);
 171         when(scheduledFuture2.isCancelled()).thenReturn(true);
 172         when(scheduledFuture3.isCancelled()).thenReturn(false);
 173         when(scheduledFuture4.isCancelled()).thenReturn(false);
 174         when(taskScheduler.scheduleAtFixedRate(any(Runnable.class), any(Instant.class), any(Duration.class)))
 175                 .thenReturn(scheduledFuture1)
 176                 .thenReturn(scheduledFuture2)
 177                 .thenReturn(scheduledFuture3)
 178                 .thenReturn(scheduledFuture4);
 179
 180         applicationScheduler.setupScheduler();
 181         boolean result = applicationScheduler.reScheduleProcessingTasks();
 182         assertAll("Rescheduling with cancelled tasks",
 183             () -> assertTrue(result, "Result of re-scheduling"),
 184             () -> assertEquals(2, applicationScheduler.numberOfTotalTasks(), "Total tasks"),
 185             () -> assertEquals(2, applicationScheduler.numberOfActiveTasks(), "Active tasks"),
 186             () -> assertEquals(0, applicationScheduler.numberOfCancelledTasks(), "Cancelled tasks")
 187         );
 188     }
 189 }