Add getMap, fix failing test

katcharov · katcharov · commit d0099cdd0525 · 2022-12-14T14:37:41.000-07:00
diff --git a/driver-core/src/main/com/mongodb/client/model/expressions/DocumentExpression.java b/driver-core/src/main/com/mongodb/client/model/expressions/DocumentExpression.java
@@ -21,6 +21,7 @@
 import java.time.Instant;
 
 import static com.mongodb.client.model.expressions.Expressions.of;
+import static com.mongodb.client.model.expressions.Expressions.ofMap;
 
 /**
  * Expresses a document value. A document is an ordered set of fields, where the
@@ -85,6 +86,13 @@ default DocumentExpression getDocument(final String fieldName, final Bson other)
         return getDocument(fieldName, of(other));
     }
 
+    <T extends Expression> MapExpression<T> getMap(String fieldName);
+    <T extends Expression> MapExpression<T> getMap(String fieldName, MapExpression<T> other);
+
+    default <T extends Expression> MapExpression<T> getMap(final String fieldName, final Bson other) {
+        return getMap(fieldName, ofMap(other));
+    }
+
     <T extends Expression> ArrayExpression<T> getArray(String fieldName);
 
     <T extends Expression> ArrayExpression<T> getArray(String fieldName, ArrayExpression<? extends T> other);
diff --git a/driver-core/src/main/com/mongodb/client/model/expressions/Expression.java b/driver-core/src/main/com/mongodb/client/model/expressions/Expression.java
@@ -111,5 +111,7 @@ public interface Expression {
     <T extends Expression> ArrayExpression<T> isArrayOr(ArrayExpression<? extends T> other);
     <T extends DocumentExpression> T isDocumentOr(T other);
 
+    <T extends Expression> MapExpression<T> isMapOr(MapExpression<T> other);
+
     StringExpression asString();
 }
diff --git a/driver-core/src/main/com/mongodb/client/model/expressions/MqlExpression.java b/driver-core/src/main/com/mongodb/client/model/expressions/MqlExpression.java
@@ -237,6 +237,16 @@ public DocumentExpression getDocument(final String fieldName) {
         return new MqlExpression<>(getFieldInternal(fieldName));
     }
 
+    @Override
+    public <R extends Expression> MapExpression<R> getMap(final String field) {
+        return new MqlExpression<>(getFieldInternal(field));
+    }
+
+    @Override
+    public <R extends Expression> MapExpression<R> getMap(final String field, final MapExpression<R> other) {
+        return getMap(field).isMapOr(other);
+    }
+
     @Override
     public DocumentExpression getDocument(final String fieldName, final DocumentExpression other) {
         return getDocument(fieldName).isDocumentOr(other);
@@ -381,6 +391,15 @@ public <R extends DocumentExpression> R isDocumentOr(final R other) {
         return this.isDocument().cond(this.assertImplementsAllExpressions(), other);
     }
 
+    public BooleanExpression isMap() {
+        return new MqlExpression<>(ast("$type")).eq(of("object"));
+    }
+
+    @Override
+    public <R extends Expression> MapExpression<R> isMapOr(final MapExpression<R> other) {
+        return this.isMap().cond(this.assertImplementsAllExpressions(), other);
+    }
+
     @Override
     public StringExpression asString() {
         return new MqlExpression<>(astWrapped("$toString"));
diff --git a/driver-core/src/test/functional/com/mongodb/client/model/expressions/DocumentExpressionsFunctionalTest.java b/driver-core/src/test/functional/com/mongodb/client/model/expressions/DocumentExpressionsFunctionalTest.java
@@ -27,6 +27,7 @@
 
 import static com.mongodb.client.model.expressions.Expressions.of;
 import static com.mongodb.client.model.expressions.Expressions.ofIntegerArray;
+import static com.mongodb.client.model.expressions.Expressions.ofMap;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @SuppressWarnings("ConstantConditions")
@@ -120,6 +121,8 @@ public void getFieldOrTest() {
         // no convenience for arrays
         assertExpression(Document.parse("{b: 2}"), ofDoc("{a: {b: 2}}")
                 .getDocument("a", Document.parse("{z: 99}")));
+        assertExpression(Document.parse("{b: 2}"), ofDoc("{a: {b: 2}}")
+                .getMap("a", Document.parse("{z: 99}")));
 
         // normal
         assertExpression(true, ofDoc("{a: true}").getBoolean("a", of(false)));
@@ -131,6 +134,8 @@ public void getFieldOrTest() {
         assertExpression(Arrays.asList(3, 2), ofDoc("{a: [3, 2]}").getArray("a", ofIntegerArray(99, 88)));
         assertExpression(Document.parse("{b: 2}"), ofDoc("{a: {b: 2}}")
                 .getDocument("a", of(Document.parse("{z: 99}"))));
+        assertExpression(Document.parse("{b: 2}"), ofDoc("{a: {b: 2}}")
+                .getMap("a", ofMap(Document.parse("{z: 99}"))));
 
         // right branch (missing field)
         assertExpression(false, ofDoc("{}").getBoolean("a", false));
@@ -145,6 +150,8 @@ public void getFieldOrTest() {
         assertExpression(Arrays.asList(99, 88), ofDoc("{}").getArray("a", ofIntegerArray(99, 88)));
         assertExpression(Document.parse("{z: 99}"), ofDoc("{}")
                 .getDocument("a", Document.parse("{z: 99}")));
+        assertExpression(Document.parse("{z: 99}"), ofDoc("{}")
+                .getMap("a", Document.parse("{z: 99}")));
 
         // int vs num
         assertExpression(99, ofDoc("{a: 1.1}").getInteger("a", of(99)));
diff --git a/driver-core/src/test/functional/com/mongodb/client/model/expressions/MapExpressionsFunctionalTest.java b/driver-core/src/test/functional/com/mongodb/client/model/expressions/MapExpressionsFunctionalTest.java
@@ -117,6 +117,16 @@ public void entrySetTest() {
                         .entrySet()
                         .map(v -> v.setValue(v.getValue().add(1)))
                         .asMap(v -> v));
+
+        // via getMap
+        DocumentExpression doc = of(Document.parse("{ instock: { warehouse1: 2500, warehouse2: 500 } }"));
+        assertExpression(
+                Arrays.asList(
+                        Document.parse("{'k': 'warehouse1', 'v': 2500}"),
+                        Document.parse("{'k': 'warehouse2', 'v': 500}")),
+                doc.getMap("instock").entrySet(),
+                "{'$objectToArray': {'$getField': {'input': {'$literal': "
+                        + "{'instock': {'warehouse1': 2500, 'warehouse2': 500}}}, 'field': 'instock'}}}");
     }
 
     @Test
diff --git a/driver-core/src/test/functional/com/mongodb/client/model/expressions/TypeExpressionsFunctionalTest.java b/driver-core/src/test/functional/com/mongodb/client/model/expressions/TypeExpressionsFunctionalTest.java
@@ -30,6 +30,7 @@
 
 import static com.mongodb.client.model.expressions.Expressions.of;
 import static com.mongodb.client.model.expressions.Expressions.ofIntegerArray;
+import static com.mongodb.client.model.expressions.Expressions.ofMap;
 import static com.mongodb.client.model.expressions.Expressions.ofNull;
 import static java.time.format.DateTimeFormatter.ISO_LOCAL_DATE_TIME;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -103,13 +104,44 @@ public void isArrayOrTest() {
     @Test
     public void isDocumentOrTest() {
         BsonDocument doc = BsonDocument.parse("{a: 1}");
-        assertExpression(doc,
+        assertExpression(
+                doc,
                 of(doc).isDocumentOr(of(BsonDocument.parse("{b: 2}"))),
                 "{'$cond': [{'$eq': [{'$type': {'$literal': {'a': 1}}}, 'object']}, "
                         + "{'$literal': {'a': 1}}, {'$literal': {'b': 2}}]}");
         // non-document:
         assertExpression(doc, ofIntegerArray(1).isDocumentOr(of(doc)));
         assertExpression(doc, ofNull().isDocumentOr(of(doc)));
+
+        // maps are documents
+        assertExpression(doc, ofMap(doc).isDocumentOr(of(BsonDocument.parse("{x: 9}"))));
+
+        // conversion between maps and documents
+        MapExpression<IntegerExpression> first = ofMap(doc);
+        DocumentExpression second = first.isDocumentOr(of(BsonDocument.parse("{}")));
+        MapExpression<IntegerExpression> third = second.isMapOr(ofMap(BsonDocument.parse("{}")));
+        assertExpression(
+                true,
+                first.eq(second));
+        assertExpression(
+                true,
+                second.eq(third));
+    }
+
+    @Test
+    public void isMapOrTest() {
+        BsonDocument map = BsonDocument.parse("{a: 1}");
+        assertExpression(
+                map,
+                ofMap(map).isMapOr(ofMap(BsonDocument.parse("{b: 2}"))),
+                "{'$cond': [{'$eq': [{'$type': {'$literal': {'a': 1}}}, 'object']}, "
+                        + "{'$literal': {'a': 1}}, {'$literal': {'b': 2}}]}");
+        // non-map:
+        assertExpression(map, ofIntegerArray(1).isMapOr(ofMap(map)));
+        assertExpression(map, ofNull().isMapOr(ofMap(map)));
+
+        // documents are maps
+        assertExpression(map, of(map).isMapOr(ofMap(BsonDocument.parse("{x: 9}"))));
     }
 
     // conversions

Original file line number	Diff line number	Diff line change
`@@ -111,5 +111,7 @@ public interface Expression {`
`111`	`111`	`<T extends Expression> ArrayExpression<T> isArrayOr(ArrayExpression<? extends T> other);`
`112`	`112`	`<T extends DocumentExpression> T isDocumentOr(T other);`
`113`	`113`
	`114`	`+ <T extends Expression> MapExpression<T> isMapOr(MapExpression<T> other);`
	`115`	`+`
`114`	`116`	`StringExpression asString();`
`115`	`117`	`}`