fix: remove deprecated use of MongoDatabase.listCollectionNames()

Author: dieppa

build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 
 
 group = "io.flamingock"
-version = "1.1.0-SNAPSHOT"
+version = "1.3.0-SNAPSHOT"
 
 val flamingockVersion = "1.2.0-beta.2"//only for test
 val templateApiVersion = "1.3.1"

src/main/java/io/flamingock/template/mongodb/model/operator/CreateCollectionOperator.java

@@ -15,6 +15,7 @@
  */
 package io.flamingock.template.mongodb.model.operator;
 
+import com.mongodb.MongoCommandException;
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.MongoDatabase;
 import io.flamingock.template.mongodb.model.MongoOperation;
@@ -27,11 +28,15 @@ public CreateCollectionOperator(MongoDatabase mongoDatabase, MongoOperation oper
 
     @Override
     public void applyInternal(ClientSession clientSession) {
-        if (DatabaseInspector.collectionExists(mongoDatabase, op.getCollection())) {
-            logger.info("Collection '{}' already exists, skipping createCollection", op.getCollection());
-            return;
+        try {
+            mongoDatabase.createCollection(op.getCollection());
+        } catch (MongoCommandException e) {
+            if (e.getErrorCode() == 48) { // NamespaceExists
+                logger.info("Collection '{}' already exists, skipping createCollection", op.getCollection());
+                return;
+            }
+            throw e;
         }
-        mongoDatabase.createCollection(op.getCollection());
     }
 
 }

src/main/java/io/flamingock/template/mongodb/model/operator/CreateViewOperator.java

@@ -15,6 +15,7 @@
  */
 package io.flamingock.template.mongodb.model.operator;
 
+import com.mongodb.MongoCommandException;
 import com.mongodb.client.ClientSession;
 import com.mongodb.client.MongoDatabase;
 import com.mongodb.client.model.CreateViewOptions;
@@ -34,12 +35,16 @@ public CreateViewOperator(MongoDatabase mongoDatabase, MongoOperation operation)
 
     @Override
     protected void applyInternal(ClientSession clientSession) {
-        if (DatabaseInspector.collectionExists(mongoDatabase, op.getCollection())) {
-            logger.info("View '{}' already exists, skipping createView", op.getCollection());
-            return;
+        try {
+            CreateViewOptions options = CreateViewOptionsMapper.map(op.getOptions());
+            mongoDatabase.createView(op.getCollection(), getViewOn(), getPipeline(), options);
+        } catch (MongoCommandException e) {
+            if (e.getErrorCode() == 48) { // NamespaceExists
+                logger.info("View '{}' already exists, skipping createView", op.getCollection());
+                return;
+            }
+            throw e;
         }
-        CreateViewOptions options = CreateViewOptionsMapper.map(op.getOptions());
-        mongoDatabase.createView(op.getCollection(), getViewOn(), getPipeline(), options);
     }
 
     private String getViewOn() {

src/main/java/io/flamingock/template/mongodb/model/operator/DatabaseInspector.java

@@ -30,12 +30,6 @@ final class DatabaseInspector {
     private DatabaseInspector() {
     }
 
-    static boolean collectionExists(MongoDatabase database, String collectionName) {
-        return database.listCollectionNames()
-                .into(new ArrayList<>())
-                .contains(collectionName);
-    }
-
     static boolean indexExistsByName(MongoDatabase database, String collection, String indexName) {
         List<Document> indexes = database.getCollection(collection)
                 .listIndexes()

src/main/java/io/flamingock/template/mongodb/model/operator/RenameCollectionOperator.java

@@ -31,20 +31,6 @@ public RenameCollectionOperator(MongoDatabase mongoDatabase, MongoOperation oper
     @Override
     protected void applyInternal(ClientSession clientSession) {
         String targetName = getTarget();
-        boolean sourceExists = DatabaseInspector.collectionExists(mongoDatabase, op.getCollection());
-        boolean targetExists = DatabaseInspector.collectionExists(mongoDatabase, targetName);
-
-        if (!sourceExists && targetExists) {
-            logger.info("Collection '{}' already renamed to '{}', skipping renameCollection", op.getCollection(), targetName);
-            return;
-        }
-
-        if (!sourceExists) {
-            logger.warn("Source collection '{}' does not exist and target '{}' is also absent — skipping renameCollection",
-                    op.getCollection(), targetName);
-            return;
-        }
-
         MongoNamespace target = new MongoNamespace(mongoDatabase.getName(), targetName);
         RenameCollectionOptions options = RenameCollectionOptionsMapper.map(op.getOptions());
         mongoDatabase.getCollection(op.getCollection()).renameCollection(target, options);

src/test/java/io/flamingock/template/mongodb/operations/RenameCollectionOperatorTest.java

@@ -15,6 +15,7 @@
  */
 package io.flamingock.template.mongodb.operations;
 
+import io.flamingock.template.mongodb.MongoTemplateExecutionException;
 import io.flamingock.template.mongodb.model.MongoOperation;
 import io.flamingock.template.mongodb.model.operator.RenameCollectionOperator;
 import org.junit.jupiter.api.BeforeEach;
@@ -26,9 +27,6 @@
 import java.util.List;
 import java.util.Map;
 
-import io.flamingock.template.mongodb.MongoTemplateExecutionException;
-
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -50,12 +48,7 @@ void renameCollectionTest() {
         mongoDatabase.createCollection(ORIGINAL_NAME);
         assertTrue(collectionExists(ORIGINAL_NAME), "Original collection should exist before rename");
 
-        MongoOperation operation = new MongoOperation();
-        operation.setType("renameCollection");
-        operation.setCollection(ORIGINAL_NAME);
-        Map<String, Object> params = new HashMap<>();
-        params.put("target", RENAMED_NAME);
-        operation.setParameters(params);
+        MongoOperation operation = buildRenameOperation();
 
         RenameCollectionOperator operator = new RenameCollectionOperator(mongoDatabase, operation);
         operator.apply(null);
@@ -65,8 +58,8 @@ void renameCollectionTest() {
     }
 
     @Test
-    @DisplayName("WHEN renameCollection operator is applied twice THEN second call succeeds silently")
-    void renameCollectionIdempotentTest() {
+    @DisplayName("WHEN renameCollection is applied twice THEN second call fails because source no longer exists")
+    void renameCollectionFailsOnSecondAttemptTest() {
         mongoDatabase.createCollection(ORIGINAL_NAME);
         assertTrue(collectionExists(ORIGINAL_NAME), "Original collection should exist before rename");
 
@@ -77,27 +70,28 @@ void renameCollectionIdempotentTest() {
         assertFalse(collectionExists(ORIGINAL_NAME), "Original should not exist after rename");
         assertTrue(collectionExists(RENAMED_NAME), "Renamed should exist after rename");
 
-        // Second apply should not throw (source gone, target exists → already renamed)
-        assertDoesNotThrow(() -> operator.apply(null));
-        assertTrue(collectionExists(RENAMED_NAME), "Renamed should still exist after second apply");
+        // Second apply MUST fail: source is gone. Rename is a transformation, not an end-state —
+        // re-running it is not a safe no-op.
+        assertThrows(MongoTemplateExecutionException.class, () -> operator.apply(null));
+        assertTrue(collectionExists(RENAMED_NAME), "Renamed should still exist after failed second apply");
     }
 
     @Test
-    @DisplayName("WHEN source is gone and target exists THEN operation is skipped as already renamed")
-    void renameCollectionAlreadyRenamedTest() {
+    @DisplayName("WHEN source is gone and target exists THEN operation fails (cannot assume it was this rename)")
+    void renameCollectionFailsWhenSourceMissingButTargetExistsTest() {
         mongoDatabase.createCollection(RENAMED_NAME);
         assertFalse(collectionExists(ORIGINAL_NAME), "Original should not exist");
         assertTrue(collectionExists(RENAMED_NAME), "Target should already exist");
 
         MongoOperation operation = buildRenameOperation();
         RenameCollectionOperator operator = new RenameCollectionOperator(mongoDatabase, operation);
-        assertDoesNotThrow(() -> operator.apply(null));
-        assertTrue(collectionExists(RENAMED_NAME), "Target should still exist after skipped rename");
+        assertThrows(MongoTemplateExecutionException.class, () -> operator.apply(null));
+        assertTrue(collectionExists(RENAMED_NAME), "Target should still exist after failed rename");
     }
 
     @Test
-    @DisplayName("WHEN both source and target exist THEN operation throws MongoTemplateExecutionException")
-    void renameCollectionBothExistTest() {
+    @DisplayName("WHEN both source and target exist THEN operation fails with MongoTemplateExecutionException")
+    void renameCollectionFailsWhenBothExistTest() {
         mongoDatabase.createCollection(ORIGINAL_NAME);
         mongoDatabase.createCollection(RENAMED_NAME);
         assertTrue(collectionExists(ORIGINAL_NAME), "Source should exist");
@@ -109,15 +103,14 @@ void renameCollectionBothExistTest() {
     }
 
     @Test
-    @DisplayName("WHEN neither source nor target exists THEN operation is skipped gracefully")
-    void renameCollectionNeitherExistsTest() {
+    @DisplayName("WHEN neither source nor target exists THEN operation fails because source is missing")
+    void renameCollectionFailsWhenNeitherExistsTest() {
         assertFalse(collectionExists(ORIGINAL_NAME), "Source should not exist");
         assertFalse(collectionExists(RENAMED_NAME), "Target should not exist");
 
         MongoOperation operation = buildRenameOperation();
         RenameCollectionOperator operator = new RenameCollectionOperator(mongoDatabase, operation);
-        // Should skip silently — both absent means nothing to rename and nothing was renamed
-        assertDoesNotThrow(() -> operator.apply(null));
+        assertThrows(MongoTemplateExecutionException.class, () -> operator.apply(null));
         assertFalse(collectionExists(ORIGINAL_NAME), "Source should still not exist");
         assertFalse(collectionExists(RENAMED_NAME), "Target should still not exist");
     }