ceph/src/rocksdb/java/src/test/java/org/rocksdb/BackupableDBOptionsTest.java

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5
   6 package org.rocksdb;
   7
   8 import static org.assertj.core.api.Assertions.assertThat;
   9
  10 import java.util.Random;
  11
  12 import org.junit.ClassRule;
  13 import org.junit.Rule;
  14 import org.junit.Test;
  15 import org.junit.rules.ExpectedException;
  16
  17 public class BackupableDBOptionsTest {
  18
  19   private final static String ARBITRARY_PATH =
  20       System.getProperty("java.io.tmpdir");
  21
  22   @ClassRule
  23   public static final RocksMemoryResource rocksMemoryResource =
  24       new RocksMemoryResource();
  25
  26   @Rule
  27   public ExpectedException exception = ExpectedException.none();
  28
  29   public static final Random rand = PlatformRandomHelper.
  30       getPlatformSpecificRandomFactory();
  31
  32   @Test
  33   public void backupDir() {
  34     try (final BackupableDBOptions backupableDBOptions =
  35              new BackupableDBOptions(ARBITRARY_PATH)) {
  36       assertThat(backupableDBOptions.backupDir()).
  37           isEqualTo(ARBITRARY_PATH);
  38     }
  39   }
  40
  41   @Test
  42   public void env() {
  43     try (final BackupableDBOptions backupableDBOptions =
  44              new BackupableDBOptions(ARBITRARY_PATH)) {
  45       assertThat(backupableDBOptions.backupEnv()).
  46           isNull();
  47
  48       try(final Env env = new RocksMemEnv(Env.getDefault())) {
  49         backupableDBOptions.setBackupEnv(env);
  50         assertThat(backupableDBOptions.backupEnv())
  51             .isEqualTo(env);
  52       }
  53     }
  54   }
  55
  56   @Test
  57   public void shareTableFiles() {
  58     try (final BackupableDBOptions backupableDBOptions =
  59              new BackupableDBOptions(ARBITRARY_PATH)) {
  60       final boolean value = rand.nextBoolean();
  61       backupableDBOptions.setShareTableFiles(value);
  62       assertThat(backupableDBOptions.shareTableFiles()).
  63           isEqualTo(value);
  64     }
  65   }
  66
  67   @Test
  68   public void infoLog() {
  69     try (final BackupableDBOptions backupableDBOptions =
  70              new BackupableDBOptions(ARBITRARY_PATH)) {
  71       assertThat(backupableDBOptions.infoLog()).
  72           isNull();
  73
  74       try(final Options options = new Options();
  75           final Logger logger = new Logger(options){
  76             @Override
  77             protected void log(InfoLogLevel infoLogLevel, String logMsg) {
  78
  79             }
  80           }) {
  81         backupableDBOptions.setInfoLog(logger);
  82         assertThat(backupableDBOptions.infoLog())
  83             .isEqualTo(logger);
  84       }
  85     }
  86   }
  87
  88   @Test
  89   public void sync() {
  90     try (final BackupableDBOptions backupableDBOptions =
  91              new BackupableDBOptions(ARBITRARY_PATH)) {
  92       final boolean value = rand.nextBoolean();
  93       backupableDBOptions.setSync(value);
  94       assertThat(backupableDBOptions.sync()).isEqualTo(value);
  95     }
  96   }
  97
  98   @Test
  99   public void destroyOldData() {
 100     try (final BackupableDBOptions backupableDBOptions =
 101              new BackupableDBOptions(ARBITRARY_PATH);) {
 102       final boolean value = rand.nextBoolean();
 103       backupableDBOptions.setDestroyOldData(value);
 104       assertThat(backupableDBOptions.destroyOldData()).
 105           isEqualTo(value);
 106     }
 107   }
 108
 109   @Test
 110   public void backupLogFiles() {
 111     try (final BackupableDBOptions backupableDBOptions =
 112              new BackupableDBOptions(ARBITRARY_PATH)) {
 113       final boolean value = rand.nextBoolean();
 114       backupableDBOptions.setBackupLogFiles(value);
 115       assertThat(backupableDBOptions.backupLogFiles()).
 116           isEqualTo(value);
 117     }
 118   }
 119
 120   @Test
 121   public void backupRateLimit() {
 122     try (final BackupableDBOptions backupableDBOptions =
 123              new BackupableDBOptions(ARBITRARY_PATH)) {
 124       final long value = Math.abs(rand.nextLong());
 125       backupableDBOptions.setBackupRateLimit(value);
 126       assertThat(backupableDBOptions.backupRateLimit()).
 127           isEqualTo(value);
 128       // negative will be mapped to 0
 129       backupableDBOptions.setBackupRateLimit(-1);
 130       assertThat(backupableDBOptions.backupRateLimit()).
 131           isEqualTo(0);
 132     }
 133   }
 134
 135   @Test
 136   public void backupRateLimiter() {
 137     try (final BackupableDBOptions backupableDBOptions =
 138              new BackupableDBOptions(ARBITRARY_PATH)) {
 139       assertThat(backupableDBOptions.backupEnv()).
 140           isNull();
 141
 142       try(final RateLimiter backupRateLimiter =
 143               new RateLimiter(999)) {
 144         backupableDBOptions.setBackupRateLimiter(backupRateLimiter);
 145         assertThat(backupableDBOptions.backupRateLimiter())
 146             .isEqualTo(backupRateLimiter);
 147       }
 148     }
 149   }
 150
 151   @Test
 152   public void restoreRateLimit() {
 153     try (final BackupableDBOptions backupableDBOptions =
 154              new BackupableDBOptions(ARBITRARY_PATH)) {
 155       final long value = Math.abs(rand.nextLong());
 156       backupableDBOptions.setRestoreRateLimit(value);
 157       assertThat(backupableDBOptions.restoreRateLimit()).
 158           isEqualTo(value);
 159       // negative will be mapped to 0
 160       backupableDBOptions.setRestoreRateLimit(-1);
 161       assertThat(backupableDBOptions.restoreRateLimit()).
 162           isEqualTo(0);
 163     }
 164   }
 165
 166   @Test
 167   public void restoreRateLimiter() {
 168     try (final BackupableDBOptions backupableDBOptions =
 169              new BackupableDBOptions(ARBITRARY_PATH)) {
 170       assertThat(backupableDBOptions.backupEnv()).
 171           isNull();
 172
 173       try(final RateLimiter restoreRateLimiter =
 174               new RateLimiter(911)) {
 175         backupableDBOptions.setRestoreRateLimiter(restoreRateLimiter);
 176         assertThat(backupableDBOptions.restoreRateLimiter())
 177             .isEqualTo(restoreRateLimiter);
 178       }
 179     }
 180   }
 181
 182   @Test
 183   public void shareFilesWithChecksum() {
 184     try (final BackupableDBOptions backupableDBOptions =
 185              new BackupableDBOptions(ARBITRARY_PATH)) {
 186       boolean value = rand.nextBoolean();
 187       backupableDBOptions.setShareFilesWithChecksum(value);
 188       assertThat(backupableDBOptions.shareFilesWithChecksum()).
 189           isEqualTo(value);
 190     }
 191   }
 192
 193   @Test
 194   public void maxBackgroundOperations() {
 195     try (final BackupableDBOptions backupableDBOptions =
 196              new BackupableDBOptions(ARBITRARY_PATH)) {
 197       final int value = rand.nextInt();
 198       backupableDBOptions.setMaxBackgroundOperations(value);
 199       assertThat(backupableDBOptions.maxBackgroundOperations()).
 200           isEqualTo(value);
 201     }
 202   }
 203
 204   @Test
 205   public void callbackTriggerIntervalSize() {
 206     try (final BackupableDBOptions backupableDBOptions =
 207              new BackupableDBOptions(ARBITRARY_PATH)) {
 208       final long value = rand.nextLong();
 209       backupableDBOptions.setCallbackTriggerIntervalSize(value);
 210       assertThat(backupableDBOptions.callbackTriggerIntervalSize()).
 211           isEqualTo(value);
 212     }
 213   }
 214
 215   @Test
 216   public void failBackupDirIsNull() {
 217     exception.expect(IllegalArgumentException.class);
 218     try (final BackupableDBOptions opts = new BackupableDBOptions(null)) {
 219       //no-op
 220     }
 221   }
 222
 223   @Test
 224   public void failBackupDirIfDisposed() {
 225     try (final BackupableDBOptions options =
 226              setupUninitializedBackupableDBOptions(exception)) {
 227       options.backupDir();
 228     }
 229   }
 230
 231   @Test
 232   public void failSetShareTableFilesIfDisposed() {
 233     try (final BackupableDBOptions options =
 234              setupUninitializedBackupableDBOptions(exception)) {
 235       options.setShareTableFiles(true);
 236     }
 237   }
 238
 239   @Test
 240   public void failShareTableFilesIfDisposed() {
 241     try (BackupableDBOptions options =
 242              setupUninitializedBackupableDBOptions(exception)) {
 243       options.shareTableFiles();
 244     }
 245   }
 246
 247   @Test
 248   public void failSetSyncIfDisposed() {
 249     try (final BackupableDBOptions options =
 250              setupUninitializedBackupableDBOptions(exception)) {
 251       options.setSync(true);
 252     }
 253   }
 254
 255   @Test
 256   public void failSyncIfDisposed() {
 257     try (final BackupableDBOptions options =
 258              setupUninitializedBackupableDBOptions(exception)) {
 259       options.sync();
 260     }
 261   }
 262
 263   @Test
 264   public void failSetDestroyOldDataIfDisposed() {
 265     try (final BackupableDBOptions options =
 266              setupUninitializedBackupableDBOptions(exception)) {
 267       options.setDestroyOldData(true);
 268     }
 269   }
 270
 271   @Test
 272   public void failDestroyOldDataIfDisposed() {
 273     try (final BackupableDBOptions options =
 274              setupUninitializedBackupableDBOptions(exception)) {
 275       options.destroyOldData();
 276     }
 277   }
 278
 279   @Test
 280   public void failSetBackupLogFilesIfDisposed() {
 281     try (final BackupableDBOptions options =
 282              setupUninitializedBackupableDBOptions(exception)) {
 283       options.setBackupLogFiles(true);
 284     }
 285   }
 286
 287   @Test
 288   public void failBackupLogFilesIfDisposed() {
 289     try (final BackupableDBOptions options =
 290              setupUninitializedBackupableDBOptions(exception)) {
 291       options.backupLogFiles();
 292     }
 293   }
 294
 295   @Test
 296   public void failSetBackupRateLimitIfDisposed() {
 297     try (final BackupableDBOptions options =
 298              setupUninitializedBackupableDBOptions(exception)) {
 299       options.setBackupRateLimit(1);
 300     }
 301   }
 302
 303   @Test
 304   public void failBackupRateLimitIfDisposed() {
 305     try (final BackupableDBOptions options =
 306              setupUninitializedBackupableDBOptions(exception)) {
 307       options.backupRateLimit();
 308     }
 309   }
 310
 311   @Test
 312   public void failSetRestoreRateLimitIfDisposed() {
 313     try (final BackupableDBOptions options =
 314              setupUninitializedBackupableDBOptions(exception)) {
 315       options.setRestoreRateLimit(1);
 316     }
 317   }
 318
 319   @Test
 320   public void failRestoreRateLimitIfDisposed() {
 321     try (final BackupableDBOptions options =
 322              setupUninitializedBackupableDBOptions(exception)) {
 323       options.restoreRateLimit();
 324     }
 325   }
 326
 327   @Test
 328   public void failSetShareFilesWithChecksumIfDisposed() {
 329     try (final BackupableDBOptions options =
 330              setupUninitializedBackupableDBOptions(exception)) {
 331       options.setShareFilesWithChecksum(true);
 332     }
 333   }
 334
 335   @Test
 336   public void failShareFilesWithChecksumIfDisposed() {
 337     try (final BackupableDBOptions options =
 338              setupUninitializedBackupableDBOptions(exception)) {
 339       options.shareFilesWithChecksum();
 340     }
 341   }
 342
 343   private BackupableDBOptions setupUninitializedBackupableDBOptions(
 344       ExpectedException exception) {
 345     final BackupableDBOptions backupableDBOptions =
 346         new BackupableDBOptions(ARBITRARY_PATH);
 347     backupableDBOptions.close();
 348     exception.expect(AssertionError.class);
 349     return backupableDBOptions;
 350   }
 351 }