SessionPoolOptionsTest.java

/*
 * Copyright 2017 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.google.cloud.spanner;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import com.google.cloud.spanner.SessionPoolOptions.InactiveTransactionRemovalOptions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
import org.threeten.bp.Duration;

/** Unit tests for {@link com.google.cloud.spanner.SessionPoolOptions} */
@RunWith(Parameterized.class)
public class SessionPoolOptionsTest {
  @Parameter public int minSessions;

  @Parameter(1)
  public int maxSessions;

  @Parameters(name = "min sessions = {0}, max sessions = {1}")
  public static Collection<Object[]> data() {
    List<Object[]> params = new ArrayList<>();
    params.add(new Object[] {1, 1});
    params.add(new Object[] {500, 600});
    params.add(new Object[] {600, 500});

    return params;
  }

  @Test
  public void setMinMaxSessions() {
    try {
      SessionPoolOptions options =
          SessionPoolOptions.newBuilder()
              .setMinSessions(minSessions)
              .setMaxSessions(maxSessions)
              .build();
      if (minSessions > maxSessions) {
        fail("Expected exception");
      }
      assertThat(minSessions).isEqualTo(options.getMinSessions());
      assertThat(maxSessions).isEqualTo(options.getMaxSessions());
    } catch (IllegalArgumentException ex) {
      if (minSessions <= maxSessions) {
        throw ex;
      }
      assertNotNull(ex.getMessage());
    }
  }

  /**
   * Setting MaxSessions to a value lower than the default MinSessions should be allowed, and should
   * cause the MinSessions to be set to the same value as the MaxSessions.
   */
  @Test
  public void setOnlyMaxSessions() {
    final int defaultMinSessions = 100;
    // Set max sessions > DEFAULT_MIN_SESSIONS.
    SessionPoolOptions options =
        SessionPoolOptions.newBuilder().setMaxSessions(defaultMinSessions + 1).build();
    assertThat(options.getMaxSessions()).isEqualTo(defaultMinSessions + 1);
    assertThat(options.getMinSessions()).isEqualTo(defaultMinSessions);
    // Set max sessions < DEFAULT_MIN_SESSIONS.
    options = SessionPoolOptions.newBuilder().setMaxSessions(defaultMinSessions - 1).build();
    assertThat(options.getMaxSessions()).isEqualTo(defaultMinSessions - 1);
    assertThat(options.getMinSessions()).isEqualTo(defaultMinSessions - 1);
  }

  @Test
  public void setValidMinSessions() {
    SessionPoolOptions.newBuilder().setMinSessions(0).build();
    SessionPoolOptions.newBuilder().setMinSessions(1).build();
    SessionPoolOptions.newBuilder().setMinSessions(400).build();
    SessionPoolOptions.newBuilder()
        .setMaxSessions(Integer.MAX_VALUE)
        .setMinSessions(Integer.MAX_VALUE)
        .build();
  }

  @Test(expected = IllegalArgumentException.class)
  public void setNegativeMinSessions() {
    SessionPoolOptions.newBuilder().setMinSessions(-1);
  }

  @Test
  public void setValidMaxSessions() {
    SessionPoolOptions.newBuilder().setMaxSessions(1).build();
    SessionPoolOptions.newBuilder().setMaxSessions(400).build();
    SessionPoolOptions.newBuilder().setMaxSessions(Integer.MAX_VALUE).build();
  }

  @Test(expected = IllegalArgumentException.class)
  public void setZeroMaxSessions() {
    SessionPoolOptions.newBuilder().setMaxSessions(0);
  }

  @Test(expected = IllegalArgumentException.class)
  public void setNegativeMaxSessions() {
    SessionPoolOptions.newBuilder().setMaxSessions(-1);
  }

  @Test
  public void verifyDefaultInactiveTransactionRemovalOptions() {
    SessionPoolOptions sessionPoolOptions = SessionPoolOptions.newBuilder().build();
    InactiveTransactionRemovalOptions inactiveTransactionRemovalOptions =
        sessionPoolOptions.getInactiveTransactionRemovalOptions();

    assertTrue(sessionPoolOptions.warnInactiveTransactions());
    assertFalse(sessionPoolOptions.warnAndCloseInactiveTransactions());
    assertFalse(sessionPoolOptions.closeInactiveTransactions());
    assertEquals(0.95, inactiveTransactionRemovalOptions.getUsedSessionsRatioThreshold(), 0.0);
    assertEquals(Duration.ofMinutes(2), inactiveTransactionRemovalOptions.getExecutionFrequency());
    assertEquals(Duration.ofMinutes(60), inactiveTransactionRemovalOptions.getIdleTimeThreshold());
  }

  @Test
  public void setWarnIfInactiveTransactions() {
    SessionPoolOptions sessionPoolOptions =
        SessionPoolOptions.newBuilder().setWarnIfInactiveTransactions().build();

    assertTrue(sessionPoolOptions.warnInactiveTransactions());
    assertFalse(sessionPoolOptions.warnAndCloseInactiveTransactions());
    assertFalse(sessionPoolOptions.closeInactiveTransactions());
  }

  @Test
  public void setWarnAndCloseIfInactiveTransactions() {
    SessionPoolOptions sessionPoolOptions =
        SessionPoolOptions.newBuilder().setWarnAndCloseIfInactiveTransactions().build();

    assertFalse(sessionPoolOptions.warnInactiveTransactions());
    assertTrue(sessionPoolOptions.warnAndCloseInactiveTransactions());
    assertFalse(sessionPoolOptions.closeInactiveTransactions());
  }

  @Test
  public void setCloseIfInactiveTransactions() {
    SessionPoolOptions sessionPoolOptions =
        SessionPoolOptions.newBuilder().setCloseIfInactiveTransactions().build();

    assertFalse(sessionPoolOptions.warnInactiveTransactions());
    assertFalse(sessionPoolOptions.warnAndCloseInactiveTransactions());
    assertTrue(sessionPoolOptions.closeInactiveTransactions());
  }

  @Test(expected = IllegalArgumentException.class)
  public void setNegativeExecutionFrequency() {
    InactiveTransactionRemovalOptions inactiveTransactionRemovalOptions =
        InactiveTransactionRemovalOptions.newBuilder()
            .setExecutionFrequency(Duration.ofMillis(-1))
            .build();
    SessionPoolOptions.newBuilder()
        .setInactiveTransactionRemovalOptions(inactiveTransactionRemovalOptions);
  }

  @Test(expected = IllegalArgumentException.class)
  public void setNegativeIdleTimeThreshold() {
    InactiveTransactionRemovalOptions inactiveTransactionRemovalOptions =
        InactiveTransactionRemovalOptions.newBuilder()
            .setIdleTimeThreshold(Duration.ofMillis(-1))
            .build();
    SessionPoolOptions.newBuilder()
        .setInactiveTransactionRemovalOptions(inactiveTransactionRemovalOptions);
  }

  @Test
  public void setAcquireSessionTimeout() {
    SessionPoolOptions sessionPoolOptions1 =
        SessionPoolOptions.newBuilder().setAcquireSessionTimeout(Duration.ofSeconds(20)).build();
    SessionPoolOptions sessionPoolOptions2 =
        SessionPoolOptions.newBuilder()
            .setAcquireSessionTimeout(Duration.ofMillis(Long.MAX_VALUE))
            .build();

    assertEquals(Duration.ofSeconds(20), sessionPoolOptions1.getAcquireSessionTimeout());
    assertEquals(Duration.ofMillis(Long.MAX_VALUE), sessionPoolOptions2.getAcquireSessionTimeout());
  }

  @Test(expected = IllegalArgumentException.class)
  public void setAcquireSessionTimeout_valueLessThanLowerBound() {
    SessionPoolOptions.newBuilder().setAcquireSessionTimeout(Duration.ofMillis(0)).build();
  }

  @Test(expected = IllegalArgumentException.class)
  public void setAcquireSessionTimeout_valueMoreThanUpperBound() {
    SessionPoolOptions.newBuilder()
        .setAcquireSessionTimeout(Duration.ofSeconds(Long.MAX_VALUE))
        .build();
  }

  @Test
  public void verifyDefaultAcquireSessionTimeout() {
    SessionPoolOptions sessionPoolOptions = SessionPoolOptions.newBuilder().build();

    assertEquals(Duration.ofSeconds(60), sessionPoolOptions.getAcquireSessionTimeout());
  }

  @Test
  public void testRandomizePositionQPSThreshold() {
    assertEquals(0L, SessionPoolOptions.newBuilder().build().getRandomizePositionQPSThreshold());
    assertEquals(
        4L,
        SessionPoolOptions.newBuilder()
            .setRandomizePositionQPSThreshold(4L)
            .build()
            .getRandomizePositionQPSThreshold());
    assertEquals(
        10L,
        SessionPoolOptions.newBuilder()
            .setRandomizePositionQPSThreshold(4L)
            .setRandomizePositionQPSThreshold(10L)
            .build()
            .getRandomizePositionQPSThreshold());
    assertEquals(
        0L,
        SessionPoolOptions.newBuilder()
            .setRandomizePositionQPSThreshold(0L)
            .build()
            .getRandomizePositionQPSThreshold());
    assertThrows(
        IllegalArgumentException.class,
        () -> SessionPoolOptions.newBuilder().setRandomizePositionQPSThreshold(-1L));
  }

  @Test
  public void testUseMultiplexedSession() {
    assertEquals(false, SessionPoolOptions.newBuilder().build().getUseMultiplexedSession());
    assertEquals(
        true,
        SessionPoolOptions.newBuilder()
            .setUseMultiplexedSession(true)
            .build()
            .getUseMultiplexedSession());
    assertEquals(
        false,
        SessionPoolOptions.newBuilder()
            .setUseMultiplexedSession(true)
            .setUseMultiplexedSession(false)
            .build()
            .getUseMultiplexedSession());
  }

  @Test
  public void testMultiplexedSessionMaintenanceDuration() {
    assertEquals(
        Duration.ofDays(7),
        SessionPoolOptions.newBuilder().build().getMultiplexedSessionMaintenanceDuration());
    assertEquals(
        Duration.ofDays(2),
        SessionPoolOptions.newBuilder()
            .setMultiplexedSessionMaintenanceDuration(Duration.ofDays(2))
            .build()
            .getMultiplexedSessionMaintenanceDuration());
    assertEquals(
        Duration.ofDays(10),
        SessionPoolOptions.newBuilder()
            .setMultiplexedSessionMaintenanceDuration(Duration.ofDays(2))
            .setMultiplexedSessionMaintenanceDuration(Duration.ofDays(10))
            .build()
            .getMultiplexedSessionMaintenanceDuration());
  }

  @Test
  public void testWaitForMultiplexedSession() {
    assertEquals(
        Duration.ofSeconds(10),
        SessionPoolOptions.newBuilder().build().getWaitForMultiplexedSession());
    assertEquals(
        Duration.ofSeconds(20),
        SessionPoolOptions.newBuilder()
            .setWaitForMultiplexedSession(Duration.ofSeconds(20))
            .build()
            .getWaitForMultiplexedSession());
    assertEquals(
        Duration.ofSeconds(10),
        SessionPoolOptions.newBuilder()
            .setWaitForMultiplexedSession(Duration.ofSeconds(2))
            .setWaitForMultiplexedSession(Duration.ofSeconds(10))
            .build()
            .getWaitForMultiplexedSession());
  }
}