@Test public void testSampleStage() { AggregationPipeline pipeline = getDs() .createAggregation(User.class) .sample(1); final DBObject sample = ((AggregationPipelineImpl) pipeline).getStages().get(0); Assert.assertEquals(new BasicDBObject("size", 1), sample.get("$sample")); }
@Test public void testDateToString() throws ParseException { checkMinServerVersion(3.0); Date joined = new SimpleDateFormat("yyyy-MM-dd z").parse("2016-05-01 UTC"); getDs().save(new User("John Doe", joined)); AggregationPipeline pipeline = getDs() .createAggregation(User.class) .project(projection("string", expression("$dateToString", new BasicDBObject("format", "%Y-%m-%d") .append("date", "$joined")))); Iterator<StringDates> aggregate = pipeline.aggregate(StringDates.class, builder() .build()); while (aggregate.hasNext()) { StringDates next = aggregate.next(); Assert.assertEquals("2016-05-01", next.string); } }
@Test public void testAdd() { AggregationPipeline pipeline = getDs() .createAggregation(Book.class) .group(grouping("summation", accumulator("$sum", accumulator("$add", asList("$amountFromTBInDouble", "$amountFromParentPNLInDouble")) ))); DBObject group = (DBObject) ((AggregationPipelineImpl) pipeline).getStages().get(0).get("$group"); DBObject summation = (DBObject) group.get("summation"); DBObject sum = (DBObject) summation.get("$sum"); List<?> add = (List<?>) sum.get("$add"); Assert.assertTrue(add.get(0) instanceof String); Assert.assertEquals("$amountFromTBInDouble", add.get(0)); pipeline.aggregate(User.class); }
@Test public void testNullGroupId() { AggregationPipeline pipeline = getDs() .createAggregation(User.class) .group(grouping("count", accumulator("$sum", 1))); final DBObject group = ((AggregationPipelineImpl) pipeline).getStages().get(0); Assert.assertNull(group.get("_id")); pipeline.aggregate(User.class); }
@Test public void testLimit() { getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Iterator<Book> aggregate = getDs().createAggregation(Book.class) .limit(2) .aggregate(Book.class); int count = 0; while (aggregate.hasNext()) { aggregate.next(); count++; } Assert.assertEquals(2, count); }
@Test public void testSkip() { getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Book book = getDs().createAggregation(Book.class) .skip(2) .aggregate(Book.class).next(); Assert.assertEquals("Eclogues", book.title); Assert.assertEquals("Dante", book.author); Assert.assertEquals(2, book.copies.intValue()); }
@Test public void testBucketWithoutOptions() { checkMinServerVersion(3.4); getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Iterator<BucketResult> aggregate = getDs().createAggregation(Book.class) .bucket("copies", Arrays.asList(1, 5, 12)).aggregate(BucketResult.class); BucketResult result1 = aggregate.next(); assertEquals(result1.id, "1"); assertEquals(result1.count, 3); BucketResult result2 = aggregate.next(); assertEquals(result2.id, "5"); assertEquals(result2.count, 2); }
@Test public void testDateAggregation() { AggregationPipeline pipeline = getDs() .createAggregation(User.class) .group(id(grouping("month", accumulator("$month", "date")), grouping("year", accumulator("$year", "date"))), grouping("count", accumulator("$sum", 1))); final DBObject group = ((AggregationPipelineImpl) pipeline).getStages().get(0); final DBObject id = getDBObject(group, "$group", "_id"); Assert.assertEquals(new BasicDBObject("$month", "$date"), id.get("month")); Assert.assertEquals(new BasicDBObject("$year", "$date"), id.get("year")); pipeline.aggregate(User.class); }
@Test public void averageCitySizeByState() { Assume.assumeTrue(new File(MONGO_IMPORT).exists()); installSampleData(); AggregationPipeline pipeline = getDs().createAggregation(City.class) .group(id(grouping("state"), grouping("city")), grouping("pop", sum("pop"))) .group("_id.state", grouping("avgCityPop", average("pop"))); validate((MongoCursor<Population>) pipeline.aggregate(Population.class), "MN", 5372); }
@Test public void testBucketAutoWithoutGranularity() { getDs().save(asList(new Book("The Banquet", "Dante", 5), new Book("Divine Comedy", "Dante", 10), new Book("Eclogues", "Dante", 40), new Book("The Odyssey", "Homer", 21))); Iterator<BucketAutoResult> aggregate = getDs().createAggregation(Book.class) .bucketAuto("copies", 2) .aggregate(BucketAutoResult.class); BucketAutoResult result1 = aggregate.next(); assertEquals(result1.id.min, 5); assertEquals(result1.id.max, 21); assertEquals(result1.count, 2); result1 = aggregate.next(); assertEquals(result1.id.min, 21); assertEquals(result1.id.max, 40); assertEquals(result1.count, 2); assertFalse(aggregate.hasNext()); }
@Test public void testSortByCount() { checkMinServerVersion(3.4); getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Iterator<SortByCountResult> aggregate = getDs().createAggregation(Book.class) .sortByCount("author").aggregate(SortByCountResult.class); SortByCountResult result1 = aggregate.next(); assertEquals(result1.id, "Dante"); assertEquals(result1.count, 3); SortByCountResult result2 = aggregate.next(); assertEquals(result2.id, "Homer"); assertEquals(result2.count, 2); }
@Test public void testBucketWithOptions() { getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Iterator<BucketResult> aggregate = getDs().createAggregation(Book.class) .bucket("copies", Arrays.asList(1, 5, 10), new BucketOptions() .defaultField("test") .output("count").sum(1)) .aggregate(BucketResult.class); BucketResult result1 = aggregate.next(); assertEquals(result1.id, "1"); assertEquals(result1.count, 3); BucketResult result2 = aggregate.next(); assertEquals(result2.id, "test"); assertEquals(result2.count, 2); }
@Test public void populationsAbove10M() { Assume.assumeTrue(new File(MONGO_IMPORT).exists()); installSampleData(); Query<Object> query = getDs().getQueryFactory().createQuery(getDs()); AggregationPipeline pipeline = getDs().createAggregation(City.class) .group("state", grouping("totalPop", sum("pop"))) .match(query.field("totalPop").greaterThanOrEq(10000000)); validate((MongoCursor<Population>) pipeline.aggregate(Population.class), "CA", 29754890); validate((MongoCursor<Population>) pipeline.aggregate(Population.class), "OH", 10846517); }
@Test public void testCollation() { checkMinServerVersion(3.4); getDs().save(asList(new User("john doe", new Date()), new User("John Doe", new Date()))); Query query = getDs().find(User.class).field("name").equal("john doe"); AggregationPipeline pipeline = getDs() .createAggregation(User.class) .match(query); Assert.assertEquals(1, count(pipeline.aggregate(User.class))); Assert.assertEquals(2, count(pipeline.aggregate(User.class, builder() .collation(Collation.builder() .locale("en") .collationStrength( CollationStrength.SECONDARY) .build()).build()))); }
@Test(expected = RuntimeException.class) public void testBucketWithUnsortedBoundaries() { checkMinServerVersion(3.4); getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Iterator<BucketResult> aggregate = getDs().createAggregation(Book.class) .bucket("copies", Arrays.asList(5, 1, 10), new BucketOptions() .defaultField("test") .output("count") .sum(1)) .aggregate(BucketResult.class); }
@Test(expected = RuntimeException.class) public void testBucketWithBoundariesWithSizeLessThanTwo() { checkMinServerVersion(3.4); getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Iterator<BucketResult> aggregate = getDs().createAggregation(Book.class) .bucket("copies", Arrays.asList(10), new BucketOptions() .defaultField("test") .output("count") .sum(1)) .aggregate(BucketResult.class); }
@Test public void testGenericAccumulatorUsage() { getDs().save(asList(new Book("The Banquet", "Dante", 2), new Book("Divine Comedy", "Dante", 1), new Book("Eclogues", "Dante", 2), new Book("The Odyssey", "Homer", 10), new Book("Iliad", "Homer", 10))); Iterator<CountResult> aggregation = getDs().createAggregation(Book.class) .group("author", grouping("count", accumulator("$sum", 1))) .sort(ascending("_id")) .aggregate(CountResult.class); CountResult result1 = aggregation.next(); CountResult result2 = aggregation.next(); Assert.assertFalse("Expecting two results", aggregation.hasNext()); Assert.assertEquals("Dante", result1.getAuthor()); Assert.assertEquals(3, result1.getCount()); Assert.assertEquals("Homer", result2.getAuthor()); Assert.assertEquals(2, result2.getCount()); }
@Test public void testUserPreferencesPipeline() { final AggregationPipeline pipeline = getDs().createAggregation(Book.class) /* the class is irrelevant for this test */ .group("state", Group.grouping("total_pop", sum("pop"))) .match(getDs().find(Book.class) .disableValidation() .field("total_pop").greaterThanOrEq(10000000)); DBObject group = obj("$group", obj("_id", "$state") .append("total_pop", obj("$sum", "$pop"))); DBObject match = obj("$match", obj("total_pop", obj("$gte", 10000000))); final List<DBObject> stages = ((AggregationPipelineImpl) pipeline).getStages(); Assert.assertEquals(stages.get(0), group); Assert.assertEquals(stages.get(1), match); }
@Test public void testGroupWithProjection() { AggregationPipeline pipeline = getDs().createAggregation(Author.class) .group("subjectHash", grouping("authors", addToSet("fromAddress.address")), grouping("messageDataSet", grouping("$addToSet", projection("sentDate", "sentDate"), projection("messageId", "_id"))), grouping("messageCount", accumulator("$sum", 1))) .limit(10) .skip(0); List<DBObject> stages = ((AggregationPipelineImpl) pipeline).getStages(); DBObject group = stages.get(0); DBObject addToSet = getDBObject(group, "$group", "messageDataSet", "$addToSet"); Assert.assertNotNull(addToSet); Assert.assertEquals(addToSet.get("sentDate"), "$sentDate"); Assert.assertEquals(addToSet.get("messageId"), "$_id"); }
@Test public void testOutNamedCollection() { checkMinServerVersion(2.6); getDs().save(asList(new Book("The Banquet", "Dante", 2, "Italian", "Sophomore Slump"), new Book("Divine Comedy", "Dante", 1, "Not Very Funny", "I mean for a 'comedy'", "Ironic"), new Book("Eclogues", "Dante", 2, "Italian", ""), new Book("The Odyssey", "Homer", 10, "Classic", "Mythology", "Sequel"), new Book("Iliad", "Homer", 10, "Mythology", "Trojan War", "No Sequel"))); getDs().createAggregation(Book.class) .match(getDs().getQueryFactory().createQuery(getDs()) .field("author").equal("Homer")) .group("author", grouping("copies", sum("copies"))) .out("testAverage", Author.class); DBCursor testAverage = getDb().getCollection("testAverage").find(); Assert.assertNotNull(testAverage); try { Assert.assertEquals(20, testAverage.next().get("copies")); } finally { testAverage.close(); } }