Propagate WriteResult(s) (like update and delete counts) from Mongo b…

…ackend to Repository API.

Fixes #1376

criteria/common/src/org/immutables/criteria/backend/WriteResults.java

@@ -23,7 +23,7 @@ final class WriteResults {
 
   static final ImmutableWriteResult UNKNOWN = ImmutableWriteResult.builder().build();
 
-  static final ImmutableWriteResult EMPTY = ImmutableWriteResult.builder().deletedCount(0).updatedCount(0).updatedCount(0).build();
+  static final ImmutableWriteResult EMPTY = ImmutableWriteResult.builder().deletedCount(0).updatedCount(0).insertedCount(0).build();
 
   private WriteResults () {}
 }

criteria/common/test/org/immutables/criteria/backend/WriteResultsTest.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2022 Immutables Authors and Contributors
+ *
+ * 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 org.immutables.criteria.backend;
+
+import org.junit.jupiter.api.Test;
+
+import static org.immutables.check.Checkers.check;
+
+class WriteResultsTest {
+  @Test
+  void empty() {
+    WriteResult empty = WriteResult.empty();
+    check(empty.insertedCount().getAsLong()).is(0L);
+    check(empty.updatedCount().getAsLong()).is(0L);
+    check(empty.deletedCount().getAsLong()).is(0L);
+    check(empty.totalCount().getAsLong()).is(0L);
+  }
+
+  @Test
+  void unknown() {
+    ImmutableWriteResult unknown = WriteResult.unknown();
+    check(!unknown.insertedCount().isPresent());
+    check(!unknown.updatedCount().isPresent());
+    check(!unknown.deletedCount().isPresent());
+    check(!unknown.totalCount().isPresent());
+    check(unknown.withUpdatedCount(1).updatedCount().getAsLong()).is(1L);
+  }
+
+  @Test
+  void totalCount() {
+    ImmutableWriteResult empty = WriteResult.empty();
+    check(empty.totalCount().getAsLong()).is(0L);
+    check(empty.withInsertedCount(1).totalCount().getAsLong()).is(1L);
+    check(empty.withDeletedCount(1).withInsertedCount(1)
+            .totalCount().getAsLong()).is(2L);
+  }
+}

criteria/mongo/src/org/immutables/criteria/mongo/MongoSession.java

@@ -235,7 +235,10 @@ private <T> Publisher<WriteResult> update(StandardOperations.Update operation) {
             .collect(Collectors.toList());
 
     Publisher<BulkWriteResult> publisher = ((MongoCollection<Object>) collection).bulkWrite(docs);
-    return Flowable.fromPublisher(publisher).map(x -> WriteResult.unknown());
+    return Flowable.fromPublisher(publisher).map(x -> WriteResult.empty()
+            .withUpdatedCount(x.getModifiedCount())
+            .withInsertedCount(x.getInsertedCount())
+            .withDeletedCount(x.getDeletedCount()));
   }
 
   private Publisher<WriteResult> updateByQuery(StandardOperations.UpdateByQuery operation) {
@@ -255,8 +258,8 @@ private Publisher<WriteResult> updateByQuery(StandardOperations.UpdateByQuery op
     });
 
     return Flowable.fromPublisher(collection.updateMany(filter, new Document("$set", set)))
-            .map(x -> WriteResult.unknown());
-
+            .map(x -> WriteResult.empty()
+                    .withUpdatedCount(x.getModifiedCount()));
   }
 
   private Publisher<WriteResult> delete(StandardOperations.Delete delete) {
@@ -278,7 +281,7 @@ private Publisher<WriteResult> deleteByKey(StandardOperations.DeleteByKey delete
   private Publisher<WriteResult> insert(StandardOperations.Insert insert) {
     final MongoCollection<Object> collection = (MongoCollection<Object>) this.collection;
     final List<Object> values = insert.values();
-    return Flowable.fromPublisher(collection.insertMany(values)).map(r -> WriteResult.unknown());
+    return Flowable.fromPublisher(collection.insertMany(values)).map(r -> WriteResult.empty().withInsertedCount(r.getInsertedIds().size()));
   }
 
   private Publisher<?> getByKey(StandardOperations.GetByKey getByKey) {

criteria/mongo/test/org/immutables/criteria/mongo/MongoWriteResultTest.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2022 Immutables Authors and Contributors
+ *
+ * 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 org.immutables.criteria.mongo;
+
+import com.google.common.collect.ImmutableList;
+import com.mongodb.reactivestreams.client.MongoDatabase;
+import org.immutables.criteria.backend.WriteResult;
+import org.immutables.criteria.personmodel.ImmutablePerson;
+import org.immutables.criteria.personmodel.Person;
+import org.immutables.criteria.personmodel.PersonCriteria;
+import org.immutables.criteria.personmodel.PersonGenerator;
+import org.immutables.criteria.personmodel.PersonRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import static org.immutables.check.Checkers.check;
+
+/**
+ * Validate results of a mongo write operation with {@link WriteResult}.
+ */
+@ExtendWith(MongoExtension.class)
+class MongoWriteResultTest {
+  private final PersonRepository repository;
+  private final PersonCriteria person;
+
+  private final PersonGenerator generator;
+
+  MongoWriteResultTest(MongoDatabase database) {
+    BackendResource backend = new BackendResource(database);
+    this.repository = new PersonRepository(backend.backend());
+    this.person = PersonCriteria.person;
+    this.generator = new PersonGenerator();
+  }
+
+  @Test
+  void insert() {
+    WriteResult result = repository.insert(generator.next());
+    check(result.insertedCount().getAsLong()).is(1L);
+    check(result.deletedCount().getAsLong()).is(0L);
+    check(result.updatedCount().getAsLong()).is(0L);
+
+    WriteResult result2 = repository.insertAll(ImmutableList.of(generator.next(), generator.next()));
+    check(result2.insertedCount().getAsLong()).is(2L);
+    check(result2.deletedCount().getAsLong()).is(0L);
+    check(result2.updatedCount().getAsLong()).is(0L);
+  }
+
+  @Test
+  void delete() {
+    WriteResult result = repository.delete(person.id.is("__missing__"));
+    check(result.insertedCount().getAsLong()).is(0L);
+    check(result.deletedCount().getAsLong()).is(0L);
+    check(result.updatedCount().getAsLong()).is(0L);
+    check(result.totalCount().getAsLong()).is(0L);
+
+    Person person1 = generator.next();
+    repository.insert(person1);
+    WriteResult result2 = repository.delete(person.id.is(person1.id()));
+    check(result2.deletedCount().getAsLong()).is(1L);
+  }
+
+  @Test
+  void update() {
+    WriteResult result1 = repository.update(person.id.is("aaa")).set(person.fullName, "name1").execute();
+    check(result1.updatedCount().getAsLong()).is(0L);
+    check(result1.insertedCount().getAsLong()).is(0L);
+    check(result1.deletedCount().getAsLong()).is(0L);
+
+    ImmutablePerson person1 = generator.next();
+    repository.insert(person1);
+
+    WriteResult result2 = repository.update(person.id.is(person1.id())).set(person.fullName, "name2").execute();
+    check(result2.updatedCount().getAsLong()).is(1L);
+    check(result2.insertedCount().getAsLong()).is(0L);
+    check(result2.deletedCount().getAsLong()).is(0L);
+  }
+}