|
15 | 15 | */
|
16 | 16 | package org.springframework.data.mongodb.core.aggregation;
|
17 | 17 |
|
18 |
| -import org.bson.Document; |
19 |
| -import org.junit.jupiter.api.Test; |
20 |
| -import org.springframework.data.domain.Sort; |
21 |
| -import org.springframework.data.mongodb.core.aggregation.ArrayOperators.ArrayToObject; |
22 |
| -import org.springframework.data.mongodb.core.aggregation.ArrayOperators.SortArray; |
| 18 | +import static org.springframework.data.mongodb.test.util.Assertions.*; |
23 | 19 |
|
24 | 20 | import java.util.ArrayList;
|
25 | 21 | import java.util.Arrays;
|
26 | 22 | import java.util.List;
|
27 | 23 |
|
28 |
| -import static org.springframework.data.mongodb.test.util.Assertions.assertThat; |
| 24 | +import org.bson.Document; |
| 25 | +import org.junit.jupiter.api.Test; |
| 26 | +import org.springframework.data.domain.Sort; |
| 27 | +import org.springframework.data.mongodb.core.aggregation.ArrayOperators.ArrayToObject; |
29 | 28 |
|
30 | 29 | /**
|
31 | 30 | * Unit tests for {@link ArrayOperators}
|
|
37 | 36 | */
|
38 | 37 | public class ArrayOperatorsUnitTests {
|
39 | 38 |
|
40 |
| - static final List<Object> VALUE_LIST = Arrays.asList(1, "2", new Document("_id", 3)); |
41 |
| - static final String VALUE_LIST_STRING = "[1, \"2\", { \"_id\" : 3 }]"; |
42 |
| - static final String EXPRESSION_STRING = "{ \"$stablemaster\" : \"burrich\" }"; |
43 |
| - static final Document EXPRESSION_DOC = Document.parse(EXPRESSION_STRING); |
44 |
| - static final AggregationExpression EXPRESSION = context -> EXPRESSION_DOC; |
45 |
| - |
46 |
| - @Test // DATAMONGO-2052 |
47 |
| - public void toArrayWithFieldReference() { |
48 |
| - |
49 |
| - assertThat(ArrayOperators.arrayOf("regal").toObject().toDocument(Aggregation.DEFAULT_CONTEXT)) |
50 |
| - .isEqualTo("{ $arrayToObject: \"$regal\" } "); |
51 |
| - } |
52 |
| - |
53 |
| - @Test // DATAMONGO-2052 |
54 |
| - public void toArrayWithExpression() { |
| 39 | + static final List<Object> VALUE_LIST = Arrays.asList(1, "2", new Document("_id", 3)); |
| 40 | + static final String VALUE_LIST_STRING = "[1, \"2\", { \"_id\" : 3 }]"; |
| 41 | + static final String EXPRESSION_STRING = "{ \"$stablemaster\" : \"burrich\" }"; |
| 42 | + static final Document EXPRESSION_DOC = Document.parse(EXPRESSION_STRING); |
| 43 | + static final AggregationExpression EXPRESSION = context -> EXPRESSION_DOC; |
55 | 44 |
|
56 |
| - assertThat(ArrayOperators.arrayOf(EXPRESSION).toObject().toDocument(Aggregation.DEFAULT_CONTEXT)) |
57 |
| - .isEqualTo("{ $arrayToObject: " + EXPRESSION_STRING + "} "); |
58 |
| - } |
| 45 | + @Test // DATAMONGO-2052 |
| 46 | + public void toArrayWithFieldReference() { |
59 | 47 |
|
60 |
| - @Test // DATAMONGO-2052 |
61 |
| - public void toArrayWithArgumentList() { |
| 48 | + assertThat(ArrayOperators.arrayOf("regal").toObject().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 49 | + .isEqualTo("{ $arrayToObject: \"$regal\" } "); |
| 50 | + } |
62 | 51 |
|
63 |
| - List<List<String>> source = new ArrayList<>(); |
64 |
| - source.add(Arrays.asList("king", "shrewd")); |
65 |
| - source.add(Arrays.asList("prince", "verity")); |
| 52 | + @Test // DATAMONGO-2052 |
| 53 | + public void toArrayWithExpression() { |
66 | 54 |
|
67 |
| - assertThat(ArrayToObject.arrayToObject(source).toDocument(Aggregation.DEFAULT_CONTEXT)) |
68 |
| - .isEqualTo("{ $arrayToObject: [ [ \"king\", \"shrewd\"], [ \"prince\", \"verity\" ] ] } "); |
69 |
| - } |
| 55 | + assertThat(ArrayOperators.arrayOf(EXPRESSION).toObject().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 56 | + .isEqualTo("{ $arrayToObject: " + EXPRESSION_STRING + "} "); |
| 57 | + } |
70 | 58 |
|
71 |
| - @Test // DATAMONGO-2287 |
72 |
| - public void arrayElementAtWithValueList() { |
| 59 | + @Test // DATAMONGO-2052 |
| 60 | + public void toArrayWithArgumentList() { |
73 | 61 |
|
74 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).elementAt(1).toDocument(Aggregation.DEFAULT_CONTEXT)) |
75 |
| - .isEqualTo("{ $arrayElemAt: [ " + VALUE_LIST_STRING + ", 1] } "); |
76 |
| - } |
| 62 | + List<List<String>> source = new ArrayList<>(); |
| 63 | + source.add(Arrays.asList("king", "shrewd")); |
| 64 | + source.add(Arrays.asList("prince", "verity")); |
77 | 65 |
|
78 |
| - @Test // DATAMONGO-2287 |
79 |
| - public void concatWithValueList() { |
| 66 | + assertThat(ArrayToObject.arrayToObject(source).toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 67 | + .isEqualTo("{ $arrayToObject: [ [ \"king\", \"shrewd\"], [ \"prince\", \"verity\" ] ] } "); |
| 68 | + } |
80 | 69 |
|
81 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).concat("field").toDocument(Aggregation.DEFAULT_CONTEXT)) |
82 |
| - .isEqualTo("{ $concatArrays: [ " + VALUE_LIST_STRING + ", \"$field\"] } "); |
83 |
| - } |
| 70 | + @Test // DATAMONGO-2287 |
| 71 | + public void arrayElementAtWithValueList() { |
84 | 72 |
|
85 |
| - @Test // DATAMONGO-2287 |
86 |
| - public void filterWithValueList() { |
| 73 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).elementAt(1).toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 74 | + .isEqualTo("{ $arrayElemAt: [ " + VALUE_LIST_STRING + ", 1] } "); |
| 75 | + } |
87 | 76 |
|
88 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).filter().as("var").by(new Document()) |
89 |
| - .toDocument(Aggregation.DEFAULT_CONTEXT)) |
90 |
| - .isEqualTo("{ $filter: { \"input\" : " + VALUE_LIST_STRING + ", \"as\" : \"var\", \"cond\" : {} } } "); |
91 |
| - } |
| 77 | + @Test // DATAMONGO-2287 |
| 78 | + public void concatWithValueList() { |
92 | 79 |
|
93 |
| - @Test // DATAMONGO-2287 |
94 |
| - public void lengthWithValueList() { |
| 80 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).concat("field").toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 81 | + .isEqualTo("{ $concatArrays: [ " + VALUE_LIST_STRING + ", \"$field\"] } "); |
| 82 | + } |
95 | 83 |
|
96 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).length().toDocument(Aggregation.DEFAULT_CONTEXT)) |
97 |
| - .isEqualTo("{ $size: [ " + VALUE_LIST_STRING + "] } "); |
98 |
| - } |
| 84 | + @Test // DATAMONGO-2287 |
| 85 | + public void filterWithValueList() { |
99 | 86 |
|
100 |
| - @Test // DATAMONGO-2287 |
101 |
| - public void sliceWithValueList() { |
| 87 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).filter().as("var").by(new Document()) |
| 88 | + .toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 89 | + .isEqualTo("{ $filter: { \"input\" : " + VALUE_LIST_STRING + ", \"as\" : \"var\", \"cond\" : {} } } "); |
| 90 | + } |
102 | 91 |
|
103 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).slice().itemCount(3).toDocument(Aggregation.DEFAULT_CONTEXT)) |
104 |
| - .isEqualTo("{ $slice: [ " + VALUE_LIST_STRING + ", 3] } "); |
105 |
| - } |
| 92 | + @Test // DATAMONGO-2287 |
| 93 | + public void lengthWithValueList() { |
106 | 94 |
|
107 |
| - @Test // DATAMONGO-2287 |
108 |
| - public void indexOfWithValueList() { |
| 95 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).length().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 96 | + .isEqualTo("{ $size: [ " + VALUE_LIST_STRING + "] } "); |
| 97 | + } |
109 | 98 |
|
110 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).indexOf("s1p").toDocument(Aggregation.DEFAULT_CONTEXT)) |
111 |
| - .isEqualTo("{ $indexOfArray: [ " + VALUE_LIST_STRING + ", \"s1p\"] } "); |
112 |
| - } |
| 99 | + @Test // DATAMONGO-2287 |
| 100 | + public void sliceWithValueList() { |
113 | 101 |
|
114 |
| - @Test // DATAMONGO-2287 |
115 |
| - public void reverseWithValueList() { |
| 102 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).slice().itemCount(3).toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 103 | + .isEqualTo("{ $slice: [ " + VALUE_LIST_STRING + ", 3] } "); |
| 104 | + } |
116 | 105 |
|
117 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).reverse().toDocument(Aggregation.DEFAULT_CONTEXT)) |
118 |
| - .isEqualTo("{ $reverseArray: [ " + VALUE_LIST_STRING + "] } "); |
119 |
| - } |
| 106 | + @Test // DATAMONGO-2287 |
| 107 | + public void indexOfWithValueList() { |
120 | 108 |
|
121 |
| - @Test // DATAMONGO-2287 |
122 |
| - public void zipWithValueList() { |
| 109 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).indexOf("s1p").toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 110 | + .isEqualTo("{ $indexOfArray: [ " + VALUE_LIST_STRING + ", \"s1p\"] } "); |
| 111 | + } |
123 | 112 |
|
124 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).zipWith("field").toDocument(Aggregation.DEFAULT_CONTEXT)) |
125 |
| - .isEqualTo("{ $zip: { \"inputs\": [" + VALUE_LIST_STRING + ", \"$field\"]} } "); |
126 |
| - } |
| 113 | + @Test // DATAMONGO-2287 |
| 114 | + public void reverseWithValueList() { |
127 | 115 |
|
128 |
| - @Test // DATAMONGO-2287 |
129 |
| - public void inWithValueList() { |
| 116 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).reverse().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 117 | + .isEqualTo("{ $reverseArray: [ " + VALUE_LIST_STRING + "] } "); |
| 118 | + } |
130 | 119 |
|
131 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).containsValue("$userName").toDocument(Aggregation.DEFAULT_CONTEXT)) |
132 |
| - .isEqualTo("{ \"$in\" : [\"$userName\", " + VALUE_LIST_STRING + "] }"); |
133 |
| - } |
| 120 | + @Test // DATAMONGO-2287 |
| 121 | + public void zipWithValueList() { |
134 | 122 |
|
135 |
| - @Test // GH-3694 |
136 |
| - public void firstWithValueList() { |
| 123 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).zipWith("field").toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 124 | + .isEqualTo("{ $zip: { \"inputs\": [" + VALUE_LIST_STRING + ", \"$field\"]} } "); |
| 125 | + } |
137 | 126 |
|
138 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).first().toDocument(Aggregation.DEFAULT_CONTEXT)) |
139 |
| - .isEqualTo("{ \"$first\" : " + VALUE_LIST_STRING + "}"); |
140 |
| - } |
| 127 | + @Test // DATAMONGO-2287 |
| 128 | + public void inWithValueList() { |
141 | 129 |
|
142 |
| - @Test // GH-3694 |
143 |
| - public void firstWithExpression() { |
| 130 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).containsValue("$userName").toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 131 | + .isEqualTo("{ \"$in\" : [\"$userName\", " + VALUE_LIST_STRING + "] }"); |
| 132 | + } |
144 | 133 |
|
145 |
| - assertThat(ArrayOperators.arrayOf(EXPRESSION).first().toDocument(Aggregation.DEFAULT_CONTEXT)) |
146 |
| - .isEqualTo("{ \"$first\" : " + EXPRESSION_STRING + "}"); |
147 |
| - } |
| 134 | + @Test // GH-3694 |
| 135 | + public void firstWithValueList() { |
148 | 136 |
|
149 |
| - @Test // GH-3694 |
150 |
| - public void firstWithFieldReference() { |
| 137 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).first().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 138 | + .isEqualTo("{ \"$first\" : " + VALUE_LIST_STRING + "}"); |
| 139 | + } |
151 | 140 |
|
152 |
| - assertThat(ArrayOperators.arrayOf("field").first().toDocument(Aggregation.DEFAULT_CONTEXT)) |
153 |
| - .isEqualTo("{ $first : \"$field\" }"); |
154 |
| - } |
| 141 | + @Test // GH-3694 |
| 142 | + public void firstWithExpression() { |
155 | 143 |
|
156 |
| - @Test // GH-3694 |
157 |
| - public void lastWithValueList() { |
| 144 | + assertThat(ArrayOperators.arrayOf(EXPRESSION).first().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 145 | + .isEqualTo("{ \"$first\" : " + EXPRESSION_STRING + "}"); |
| 146 | + } |
158 | 147 |
|
159 |
| - assertThat(ArrayOperators.arrayOf(VALUE_LIST).last().toDocument(Aggregation.DEFAULT_CONTEXT)) |
160 |
| - .isEqualTo("{ \"$last\" : " + VALUE_LIST_STRING + "}"); |
161 |
| - } |
| 148 | + @Test // GH-3694 |
| 149 | + public void firstWithFieldReference() { |
162 | 150 |
|
163 |
| - @Test // GH-3694 |
164 |
| - public void lastWithExpression() { |
| 151 | + assertThat(ArrayOperators.arrayOf("field").first().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 152 | + .isEqualTo("{ $first : \"$field\" }"); |
| 153 | + } |
165 | 154 |
|
166 |
| - assertThat(ArrayOperators.arrayOf(EXPRESSION).last().toDocument(Aggregation.DEFAULT_CONTEXT)) |
167 |
| - .isEqualTo("{ \"$last\" : " + EXPRESSION_STRING + "}"); |
168 |
| - } |
| 155 | + @Test // GH-3694 |
| 156 | + public void lastWithValueList() { |
169 | 157 |
|
170 |
| - @Test // GH-3694 |
171 |
| - public void lastWithFieldReference() { |
| 158 | + assertThat(ArrayOperators.arrayOf(VALUE_LIST).last().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 159 | + .isEqualTo("{ \"$last\" : " + VALUE_LIST_STRING + "}"); |
| 160 | + } |
172 | 161 |
|
173 |
| - assertThat(ArrayOperators.arrayOf("field").last().toDocument(Aggregation.DEFAULT_CONTEXT)) |
174 |
| - .isEqualTo("{ $last : \"$field\" }"); |
175 |
| - } |
| 162 | + @Test // GH-3694 |
| 163 | + public void lastWithExpression() { |
176 | 164 |
|
177 |
| - @Test |
178 |
| - // GH-4139 |
179 |
| - void sortByWithFieldRef() { |
| 165 | + assertThat(ArrayOperators.arrayOf(EXPRESSION).last().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 166 | + .isEqualTo("{ \"$last\" : " + EXPRESSION_STRING + "}"); |
| 167 | + } |
180 | 168 |
|
181 |
| - assertThat(ArrayOperators.arrayOf("team").sort(Sort.by("name")).toDocument(Aggregation.DEFAULT_CONTEXT)) |
182 |
| - .isEqualTo("{ $sortArray: { input: \"$team\", sortBy: { name: 1 } } }"); |
183 |
| - } |
| 169 | + @Test // GH-3694 |
| 170 | + public void lastWithFieldReference() { |
184 | 171 |
|
185 |
| - @Test // GH-4929 |
186 |
| - public void sortArrayByValueAscending() { |
187 |
| - Document result = SortArray.sortArrayOf("numbers").byValueAscending().toDocument(Aggregation.DEFAULT_CONTEXT); |
188 |
| - Document expected = new Document("$sortArray", new Document("input", "$numbers").append("sortBy", 1)); |
189 |
| - assertThat(result).isEqualTo(expected); |
190 |
| - } |
| 172 | + assertThat(ArrayOperators.arrayOf("field").last().toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 173 | + .isEqualTo("{ $last : \"$field\" }"); |
| 174 | + } |
191 | 175 |
|
192 |
| - @Test // GH-4929 |
193 |
| - public void sortArrayByValueDescending() { |
194 |
| - Document result = SortArray.sortArrayOf("numbers").byValueDescending().toDocument(Aggregation.DEFAULT_CONTEXT); |
195 |
| - Document expected = new Document("$sortArray", new Document("input", "$numbers").append("sortBy", -1)); |
196 |
| - assertThat(result).isEqualTo(expected); |
197 |
| - } |
| 176 | + @Test // GH-4139 |
| 177 | + void sortByWithFieldRef() { |
198 | 178 |
|
199 |
| - @Test // GH-4929 |
200 |
| - public void sortArrayByPropertyUnchanged() { |
201 |
| - Document result = SortArray.sortArrayOf("items") |
202 |
| - .by(Sort.by(Sort.Direction.ASC, "price")).toDocument(Aggregation.DEFAULT_CONTEXT); |
203 |
| - Document expected = new Document("$sortArray", new Document("input", "$items").append("sortBy", new Document("price", 1))); |
204 |
| - assertThat(result).isEqualTo(expected); |
205 |
| - } |
| 179 | + assertThat(ArrayOperators.arrayOf("team").sort(Sort.by("name")).toDocument(Aggregation.DEFAULT_CONTEXT)) |
| 180 | + .isEqualTo("{ $sortArray: { input: \"$team\", sortBy: { name: 1 } } }"); |
| 181 | + } |
206 | 182 | }
|
0 commit comments