git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.mielecloud.internal.webservice.sse;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.mockito.Mockito.*;
  17
  18 import java.util.Random;
  19
  20 import org.eclipse.jdt.annotation.NonNullByDefault;
  21 import org.junit.jupiter.api.Test;
  22
  23 /**
  24  * @author Björn Lange - Initial contribution
  25  */
  26 @NonNullByDefault
  27 public class ExponentialBackoffWithJitterTest {
  28     private static final long RETRY_INTERVAL = 2;
  29     private static final long ALTERNATIVE_RETRY_INTERVAL = 50;
  30     private static final long MINIMUM_WAIT_TIME = 1;
  31     private static final long ALTERNATIVE_MINIMUM_WAIT_TIME = 2;
  32     private static final long MAXIMUM_WAIT_TIME = 100;
  33     private static final long ALTERNATIVE_MAXIMUM_WAIT_TIME = 150;
  34
  35     @Test
  36     public void whenMinimumWaitTimeIsSmallerThanZeroThenAnIllegalArgumentExceptionIsThrown() {
  37         // when:
  38         assertThrows(IllegalArgumentException.class, () -> {
  39             new ExponentialBackoffWithJitter(-MINIMUM_WAIT_TIME, MAXIMUM_WAIT_TIME, RETRY_INTERVAL);
  40         });
  41     }
  42
  43     @Test
  44     public void whenMaximumWaitTimeIsSmallerThanZeroThenAnIllegalArgumentExceptionIsThrown() {
  45         // when:
  46         assertThrows(IllegalArgumentException.class, () -> {
  47             new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME, -MAXIMUM_WAIT_TIME, RETRY_INTERVAL);
  48         });
  49     }
  50
  51     @Test
  52     public void whenRetryIntervalIsSmallerThanZeroThenAnIllegalArgumentExceptionIsThrown() {
  53         // when:
  54         assertThrows(IllegalArgumentException.class, () -> {
  55             new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME, MAXIMUM_WAIT_TIME, -RETRY_INTERVAL);
  56         });
  57     }
  58
  59     @Test
  60     public void whenMinimumWaitTimeIsLargerThanMaximumWaitTimeThenAnIllegalArgumentExceptionIsThrown() {
  61         // when:
  62         assertThrows(IllegalArgumentException.class, () -> {
  63             new ExponentialBackoffWithJitter(MAXIMUM_WAIT_TIME, MINIMUM_WAIT_TIME, RETRY_INTERVAL);
  64         });
  65     }
  66
  67     @Test
  68     public void whenRetryIntervalIsLargerThanMaximumWaitTimeThenAnIllegalArgumentExceptionIsThrown() {
  69         // when:
  70         assertThrows(IllegalArgumentException.class, () -> {
  71             new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME, RETRY_INTERVAL, MAXIMUM_WAIT_TIME);
  72         });
  73     }
  74
  75     @Test
  76     public void whenTheNumberOfFailedAttemptsIsNegativeThenZeroIsAssumedInstead() {
  77         // given:
  78         Random random = mock(Random.class, withSettings().withoutAnnotations());
  79         when(random.nextLong()).thenReturn(RETRY_INTERVAL);
  80
  81         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME,
  82                 MAXIMUM_WAIT_TIME, RETRY_INTERVAL, random);
  83
  84         // when:
  85         long result = backoffStrategy.getSecondsUntilRetry(-10);
  86
  87         // then:
  88         assertEquals(MINIMUM_WAIT_TIME + RETRY_INTERVAL, result);
  89     }
  90
  91     @Test
  92     public void whenThereIsNoFailedAttemptThenTheMaximalResultIsMinimumWaitTimePlusRetryInterval() {
  93         // given:
  94         Random random = mock(Random.class, withSettings().withoutAnnotations());
  95         when(random.nextLong()).thenReturn(RETRY_INTERVAL);
  96
  97         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME,
  98                 MAXIMUM_WAIT_TIME, RETRY_INTERVAL, random);
  99
 100         // when:
 101         long result = backoffStrategy.getSecondsUntilRetry(0);
 102
 103         // then:
 104         assertEquals(MINIMUM_WAIT_TIME + RETRY_INTERVAL, result);
 105     }
 106
 107     @Test
 108     public void whenThereIsOneFailedAttemptThenTheMaximalResultIsMinimumWaitTimePlusTwiceTheRetryInterval() {
 109         // given:
 110         Random random = mock(Random.class, withSettings().withoutAnnotations());
 111         when(random.nextLong()).thenReturn(RETRY_INTERVAL * 2);
 112
 113         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME,
 114                 MAXIMUM_WAIT_TIME, RETRY_INTERVAL, random);
 115
 116         // when:
 117         long result = backoffStrategy.getSecondsUntilRetry(1);
 118
 119         // then:
 120         assertEquals(MINIMUM_WAIT_TIME + RETRY_INTERVAL * 2, result);
 121     }
 122
 123     @Test
 124     public void whenThereAreTwoFailedAttemptsThenTheMaximalResultIsMinimumWaitTimePlusFourTimesTheRetryInterval() {
 125         // given:
 126         Random random = mock(Random.class, withSettings().withoutAnnotations());
 127         when(random.nextLong()).thenReturn(RETRY_INTERVAL * 4);
 128
 129         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME,
 130                 MAXIMUM_WAIT_TIME, RETRY_INTERVAL, random);
 131
 132         // when:
 133         long result = backoffStrategy.getSecondsUntilRetry(2);
 134
 135         // then:
 136         assertEquals(MINIMUM_WAIT_TIME + RETRY_INTERVAL * 4, result);
 137     }
 138
 139     @Test
 140     public void whenThereAreTwoFailedAttemptsThenTheMinimalResultIsTheMinimumWaitTime() {
 141         // given:
 142         Random random = mock(Random.class, withSettings().withoutAnnotations());
 143         when(random.nextLong()).thenReturn(0L);
 144
 145         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME,
 146                 MAXIMUM_WAIT_TIME, RETRY_INTERVAL, random);
 147
 148         // when:
 149         long result = backoffStrategy.getSecondsUntilRetry(2);
 150
 151         // then:
 152         assertEquals(MINIMUM_WAIT_TIME, result);
 153     }
 154
 155     @Test
 156     public void whenTheDrawnRandomValueIsNegativeThenItIsProjectedToAPositiveValue() {
 157         // given:
 158         Random random = mock(Random.class, withSettings().withoutAnnotations());
 159         when(random.nextLong()).thenReturn(-RETRY_INTERVAL * 4 - 1);
 160
 161         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(MINIMUM_WAIT_TIME,
 162                 MAXIMUM_WAIT_TIME, RETRY_INTERVAL, random);
 163
 164         // when:
 165         long result = backoffStrategy.getSecondsUntilRetry(2);
 166
 167         // then:
 168         assertEquals(MINIMUM_WAIT_TIME, result);
 169     }
 170
 171     @Test
 172     public void whenTheResultWouldBeLargerThanTheMaximumThenItIsCappedToTheMaximum() {
 173         // given:
 174         Random random = mock(Random.class, withSettings().withoutAnnotations());
 175         when(random.nextLong()).thenReturn(MAXIMUM_WAIT_TIME - ALTERNATIVE_MINIMUM_WAIT_TIME);
 176
 177         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(ALTERNATIVE_MINIMUM_WAIT_TIME,
 178                 MAXIMUM_WAIT_TIME, ALTERNATIVE_RETRY_INTERVAL, random);
 179
 180         // when:
 181         long result = backoffStrategy.getSecondsUntilRetry(2);
 182
 183         // then:
 184         assertEquals(MAXIMUM_WAIT_TIME, result);
 185     }
 186
 187     @Test
 188     public void whenTheResultWouldBeLargerThanTheAlternativeMaximumThenItIsCappedToTheAlternativeMaximum() {
 189         // given:
 190         Random random = mock(Random.class, withSettings().withoutAnnotations());
 191         when(random.nextLong()).thenReturn(ALTERNATIVE_MAXIMUM_WAIT_TIME - ALTERNATIVE_MINIMUM_WAIT_TIME);
 192
 193         ExponentialBackoffWithJitter backoffStrategy = new ExponentialBackoffWithJitter(ALTERNATIVE_MINIMUM_WAIT_TIME,
 194                 ALTERNATIVE_MAXIMUM_WAIT_TIME, ALTERNATIVE_RETRY_INTERVAL, random);
 195
 196         // when:
 197         long result = backoffStrategy.getSecondsUntilRetry(2);
 198
 199         // then:
 200         assertEquals(ALTERNATIVE_MAXIMUM_WAIT_TIME, result);
 201     }
 202 }