feat(async): add overwriteAlias

Author: bevzzz

src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestorer.java

@@ -40,6 +40,7 @@ public class BackupRestorer extends AsyncBaseClient<BackupRestoreResponse>
   private String[] excludeClassNames;
   private String backend;
   private String backupId;
+  private Boolean overwriteAlias;
   private BackupRestoreConfig config;
   private boolean waitForCompletion;
   private final Executor executor;
@@ -81,6 +82,11 @@ public BackupRestorer withWaitForCompletion(boolean waitForCompletion) {
     return this;
   }
 
+  public BackupRestorer withOverwriteAlias(boolean overwriteAlias) {
+    this.overwriteAlias = overwriteAlias;
+    return this;
+  }
+
   @Override
   public Future<Result<BackupRestoreResponse>> run(FutureCallback<Result<BackupRestoreResponse>> callback) {
     if (waitForCompletion) {
@@ -94,6 +100,7 @@ private Future<Result<BackupRestoreResponse>> restore(FutureCallback<Result<Back
         .config(BackupRestoreConfig.builder().build())
         .include(includeClassNames)
         .exclude(excludeClassNames)
+        .overwriteAlias(overwriteAlias)
         .config(config)
         .build();
     String path = String.format("/backups/%s/%s/restore", UrlEncoder.encodePathParam(backend),
@@ -236,6 +243,8 @@ private static class BackupRestore {
     String[] include;
     @SerializedName("exclude")
     String[] exclude;
+    @SerializedName("overwriteAlias")
+    Boolean overwriteAlias;
   }
 
   @Getter

src/test/java/io/weaviate/integration/client/async/backup/ClientBackupTest.java

@@ -22,6 +22,7 @@
 import io.weaviate.client.WeaviateAuthClient;
 import io.weaviate.client.WeaviateClient;
 import io.weaviate.client.base.Result;
+import io.weaviate.client.v1.aliases.model.Alias;
 import io.weaviate.client.v1.async.WeaviateAsyncClient;
 import io.weaviate.client.v1.async.backup.api.BackupCanceler;
 import io.weaviate.client.v1.async.backup.api.BackupCreateStatusGetter;
@@ -549,6 +550,57 @@ public void shouldRestoreWithRbacOptions() {
     }
   }
 
+  @Test
+  public void testOverwriteAlias_true() throws InterruptedException, ExecutionException, Exception {
+    String originalClass = "CollectionOverwriteAlias";
+    String alias = originalClass + "Alias";
+    String differentClass = "Different" + originalClass;
+
+    try (final WeaviateAsyncClient async = client.async()) {
+      Runnable arrange = runnable(() -> {
+        Result<?> res;
+
+        res = async.schema().classCreator()
+            .withClass(WeaviateClass.builder().className(originalClass).build())
+            .run().get();
+        Assertions.assertThat(res.getError()).isNull();
+        res = async.alias().creator().withClassName(originalClass).withAlias(alias).run().get();
+        Assertions.assertThat(res.getError()).isNull();
+
+        res = async.backup().creator()
+            .withBackupId(backupId)
+            .withBackend(BackupTestSuite.BACKEND)
+            .withIncludeClassNames(originalClass)
+            .withWaitForCompletion(true)
+            .run().get();
+        Assertions.assertThat(res.getError()).isNull();
+
+        res = async.schema().classDeleter().withClassName(originalClass).run().get();
+        Assertions.assertThat(res.getError()).isNull();
+        res = async.schema().classCreator()
+            .withClass(WeaviateClass.builder().className(differentClass).build())
+            .run().get();
+        Assertions.assertThat(res.getError()).isNull();
+        res = async.alias().updater().withAlias(alias).withNewClassName(differentClass).run().get();
+        Assertions.assertThat(res.getError()).isNull();
+
+        return null; // satisfy Callable
+      });
+
+      Callable<Result<?>> act = () -> async.backup().restorer()
+          .withBackupId(backupId)
+          .withBackend(BackupTestSuite.BACKEND)
+          .withIncludeClassNames(originalClass)
+          .withWaitForCompletion(true)
+          .withOverwriteAlias(true)
+          .run().get();
+
+      Supplier<Alias> getAlias = supplier(() -> async.alias().getter().withAlias(alias).run().get().getResult());
+
+      BackupTestSuite.testOverwriteAlias_true(arrange, act, getAlias, originalClass);
+    }
+  }
+
   @FunctionalInterface
   interface ThrowingSupplier<T> {
     T get() throws Exception;