CXX-555 add test coverage for collection::distinct

Author: amidvidy

src/mongocxx/test/collection.cpp

@@ -1,7 +1,12 @@
 #include "catch.hpp"
 
+#include <vector>
+
 #include <bsoncxx/builder/stream/document.hpp>
+#include <bsoncxx/json.hpp>
+#include <bsoncxx/stdx/string_view.hpp>
 #include <bsoncxx/types.hpp>
+
 #include <mongocxx/collection.hpp>
 #include <mongocxx/client.hpp>
 #include <mongocxx/pipeline.hpp>
@@ -388,4 +393,57 @@ TEST_CASE("CRUD functionality", "[driver::collection]") {
 
         auto results = coll.aggregate(p);
     }
+
+    SECTION("distinct works", "[collection]") {
+        using bsoncxx::builder::stream::document;
+
+        auto distinct_cname = "distinct_coll";
+        auto distinct_coll = db[distinct_cname];
+        if (db.has_collection(distinct_cname)) {
+            distinct_coll.drop();
+        }
+
+        document doc1{};
+        doc1 << "foo" << "baz" << "garply" << 1;
+        document doc2{};
+        doc2 << "foo" << "bar" << "garply" << 2;
+        document doc3{};
+        doc3 << "foo" << "baz" << "garply" << 2;
+        document doc4{};
+        doc4 << "foo" << "quux" << "garply" << 9;
+
+        bulk_write bulk{false /* unordered */};
+
+        bulk.append(model::insert_one{doc1});
+        bulk.append(model::insert_one{doc2});
+        bulk.append(model::insert_one{doc3});
+        bulk.append(model::insert_one{doc4});
+
+        distinct_coll.bulk_write(bulk);
+
+        auto distinct_results = distinct_coll.distinct("foo", {});
+
+        // copy into a vector.
+        std::vector<bsoncxx::document::value> results(distinct_results.begin(),
+                                                      distinct_results.end());
+        REQUIRE(results.size() == std::size_t{1});
+
+        auto res_doc = results[0].view();
+
+        auto values_array = res_doc["values"].get_array().value;
+
+        std::vector<bsoncxx::stdx::string_view> distinct_values;
+        for (auto&& value : values_array) {
+            distinct_values.push_back(value.get_utf8().value);
+        }
+
+        const auto assert_contains_one = [&](bsoncxx::stdx::string_view val) {
+            REQUIRE(std::count(distinct_values.begin(), distinct_values.end(), val) == 1);
+        };
+
+        assert_contains_one("baz");
+        assert_contains_one("bar");
+        assert_contains_one("quux");
+    }
+
 }

src/mongocxx/test/collection_mocked.cpp

@@ -213,45 +213,6 @@ TEST_CASE("Collection", "[collection]") {
         REQUIRE(collection_create_index_called);
     }
 
-    SECTION("Distinct" "[collection::distinct]") {
-        auto database_command_called = false;
-        bool success;
-
-        database_command->interpose([&](
-            mongoc_database_t* db,
-            mongoc_query_flags_t flags,
-            uint32_t skip,
-            uint32_t limit,
-            uint32_t batch_size,
-            const bson_t* command,
-            const bson_t* fields,
-            const mongoc_read_prefs_t* read_prefs
-        ) -> mongoc_cursor_t* {
-            database_command_called = true;
-            REQUIRE(db == mongo_db.implementation());
-            // TODO: test some actual implementation details here
-            // TODO: figure out how to return a legit mongoc_cursor_t back to the driver
-            return nullptr;
-        });
-
-        SECTION("Succeeds") {
-            success = true;
-            // TODO: fixme
-            //mongo_coll.distinct("field_name", bsoncxx::document::view{});
-        }
-
-        SECTION("Fails") {
-            success = false;
-            // TODO: fixme
-            //REQUIRE_THROWS_AS(
-                //mongo_coll.distinct("field_name", bsoncxx::document::view{}),
-                //exception::operation
-            //);
-        }
-
-        //REQUIRE(database_command_called);
-    }
-
     SECTION("Drop" "[collection::drop]") {
         auto collection_drop_called = false;
         bool success;