Builders Feature Branch (#74)

# Pull Request Info

Aggregating all the changes for the Builders API reference docs

[PR Reviewing
Guidelines](https://github.com/mongodb/docs-java/blob/master/REVIEWING.md)

JIRA - n/a
Staging -
https://docs-mongodbcom-staging.corp.mongodb.com/kotlin/docsworker-xlarge/builders/

## Self-Review Checklist

- [ ] Is this free of any warnings or errors in the RST?
- [ ] Did you run a spell-check?
- [ ] Did you run a grammar-check?
- [ ] Are all the links working?

---------

Co-authored-by: cbullinger <[email protected]>
Co-authored-by: Rea Rustagi <[email protected]>
Co-authored-by: Rea Radhika Rustagi <[email protected]>

Author: 3 people

examples/src/test/kotlin/AggregatesBuilderTest.kt

@@ -19,7 +19,7 @@ internal class CountTest {
     companion object {
         val config = getConfig()
         val client = MongoClient.create(config.connectionUri)
-        private val database = client.getDatabase("sample_mflix")
+        private val database = client.getDatabase("count_test")
         val collection = database.getCollection<Movie>("movies")
 
         @BeforeAll

examples/src/test/kotlin/CountTest.kt

@@ -0,0 +1,215 @@
+
+import com.mongodb.client.model.Filters
+import com.mongodb.client.model.geojson.Point
+import com.mongodb.client.model.geojson.Polygon
+import com.mongodb.client.model.geojson.Position
+import com.mongodb.kotlin.client.coroutine.MongoClient
+import config.getConfig
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.runBlocking
+import org.bson.codecs.pojo.annotations.BsonId
+import org.junit.jupiter.api.AfterAll
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+
+class FiltersBuildersTest {
+    // :snippet-start: paint-order-data-class
+    data class PaintOrder(
+        @BsonId val id: Int,
+        val qty: Int,
+        val color: String,
+        val vendors: List<String> = mutableListOf()
+    )
+    // :snippet-end:
+
+    companion object {
+        val config = getConfig()
+        val client = MongoClient.create(config.connectionUri)
+        val database = client.getDatabase("paints_r_us")
+        val collection = database.getCollection<PaintOrder>("paints")
+
+        @BeforeAll
+        @JvmStatic
+        fun beforeAll() {
+            runBlocking {
+                val paintOrders = listOf(
+                    PaintOrder(1, 5, "red", listOf("A")),
+                    PaintOrder(2, 10, "purple", listOf("C", "D")),
+                    PaintOrder(3, 8, "blue", listOf("B", "A")),
+                    PaintOrder(4, 6, "white", listOf("D")),
+                    PaintOrder(5, 11, "yellow", listOf("A", "B")),
+                    PaintOrder(6, 5, "pink", listOf("C")),
+                    PaintOrder(7, 8, "green", listOf("B", "C")),
+                    PaintOrder(8, 7, "orange", listOf("A", "D"))
+                )
+                collection.insertMany(paintOrders)
+            }
+        }
+
+        @AfterAll
+        @JvmStatic
+        fun afterAll() {
+            runBlocking {
+                database.drop()
+                client.close()
+            }
+        }
+    }
+
+    @Test
+    fun equalComparisonTest() = runBlocking {
+        // :snippet-start: equalComparison
+        val equalComparison = Filters.eq(PaintOrder::qty.name, 5)
+        val resultsFlow = collection.find(equalComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(2, resultsFlow.toList().size)
+    }
+
+    @Test
+    fun gteComparisonTest() = runBlocking {
+        // :snippet-start: gteComparison
+        val gteComparison = Filters.gte(PaintOrder::qty.name, 10)
+        val resultsFlow = collection.find(gteComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(2, resultsFlow.toList().size)
+    }
+
+    @Test
+    fun emptyComparisonTest() = runBlocking {
+        // :snippet-start: emptyComparison
+        val emptyComparison = Filters.empty()
+        val resultsFlow = collection.find(emptyComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(8, resultsFlow.toList().size)
+    }
+
+    @Test
+    fun orComparisonTest() = runBlocking {
+        // :snippet-start: orComparison
+        val orComparison = Filters.or(
+            Filters.gt(PaintOrder::qty.name, 8),
+            Filters.eq(PaintOrder::color.name, "pink")
+        )
+        val resultsFlow = collection.find(orComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(3, resultsFlow.toList().size)
+    }
+
+    @Test
+    fun allComparisonTest() = runBlocking {
+        // :snippet-start: allComparison
+        val search = listOf("A", "D")
+        val allComparison = Filters.all(PaintOrder::vendors.name, search)
+        val resultsFlow = collection.find(allComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(1, resultsFlow.toList().size)
+    }
+
+    @Test
+    fun existsComparisonTest() = runBlocking {
+        // :snippet-start: existsComparison
+        val existsComparison = Filters.and(Filters.exists(PaintOrder::qty.name), Filters.nin("qty", 5, 8))
+        val resultsFlow = collection.find(existsComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(4, resultsFlow.toList().size)
+    }
+
+    @Test
+    fun regexComparisonTest() = runBlocking {
+        // :snippet-start: regexComparison
+        val regexComparison = Filters.regex(PaintOrder::color.name, "^p")
+        val resultsFlow = collection.find(regexComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(2, resultsFlow.toList().size)
+    }
+
+    @Test
+    fun bitsComparisonTest() = runBlocking {
+        // :snippet-start: bitsComparison
+        data class BinaryNumber(
+            @BsonId val id: Int,
+            val decimalValue: Int,
+            val binaryValue: String
+        )
+        val binaryCollection = database.getCollection<BinaryNumber>("binary_numbers")
+        // :remove-start:
+        val binaryNumbers = listOf(
+            BinaryNumber(1, 54, "00110110"),
+            BinaryNumber(2, 20, "00010100"),
+            BinaryNumber(3, 68, "1000100"),
+            BinaryNumber(4, 102, "01100110")
+        )
+        binaryCollection.insertMany(binaryNumbers)
+        // :remove-end:
+
+        val bitmask = 34.toLong() // 00100010 in binary
+        val bitsComparison = Filters.bitsAllSet(BinaryNumber::decimalValue.name, bitmask)
+        val resultsFlow = binaryCollection.find(bitsComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        val expected = listOf(
+            BinaryNumber(1, 54, "00110110"),
+            BinaryNumber(4, 102, "01100110")
+        )
+        assertEquals(expected, resultsFlow.toList())
+    }
+
+    @Test
+    fun geoWithinComparisonTest() = runBlocking {
+        // :snippet-start: geoWithinComparison
+        data class Store(
+            @BsonId val id: Int,
+            val name: String,
+            val coordinates: Point
+        )
+        val collection = database.getCollection<Store>("stores")
+        // :remove-start:
+        val stores = listOf(
+            Store(
+                13,
+                "Store 13",
+                Point(Position(2.0, 2.0))
+            ),
+            Store(
+                14,
+                "Store 14",
+                Point(Position(5.0, 6.0))
+            ),
+            Store(
+                15,
+                "Store 15",
+                Point(Position(1.0, 3.0))
+            ),
+            Store(
+                16,
+                "Store 16",
+                Point(Position(4.0, 7.0))
+            )
+        )
+        collection.insertMany(stores)
+        // :remove-end:
+
+        val square = Polygon(listOf(
+            Position(0.0, 0.0),
+            Position(4.0, 0.0),
+            Position(4.0, 4.0),
+            Position(0.0, 4.0),
+            Position(0.0, 0.0)))
+        val geoWithinComparison = Filters.geoWithin(Store::coordinates.name, square)
+
+        val resultsFlow = collection.find(geoWithinComparison)
+        resultsFlow.collect { println(it) }
+        // :snippet-end:
+        assertEquals(2, resultsFlow.toList().size)
+        assertEquals("Store 13", resultsFlow.firstOrNull()?.name)
+    }
+}

examples/src/test/kotlin/FiltersBuildersTest.kt

@@ -0,0 +1,91 @@
+
+import com.mongodb.client.model.Indexes
+import com.mongodb.kotlin.client.coroutine.MongoClient
+import config.getConfig
+import kotlinx.coroutines.runBlocking
+import org.bson.Document
+import org.junit.jupiter.api.AfterAll
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class IndexesBuildersTest {
+
+    companion object {
+        val config = getConfig()
+        val client = MongoClient.create(config.connectionUri)
+        val database = client.getDatabase("marketing")
+        val collection = database.getCollection<Document>("users")
+
+        @AfterAll
+        @JvmStatic
+        fun afterAll() {
+            runBlocking {
+                database.drop()
+                client.close()
+            }
+        }
+    }
+
+    @Test
+    fun ascendingIndexTest() = runBlocking {
+        // :snippet-start: ascending-index
+        val ascendingIndex = Indexes.ascending("name")
+        val indexName = collection.createIndex(ascendingIndex)
+        println(indexName)
+        // :snippet-end:
+        assertEquals("name_1", indexName)
+    }
+
+    @Test
+    fun descendingIndexTest() = runBlocking {
+        // :snippet-start: descending-index
+        val descendingIndex = Indexes.descending("capacity")
+        val indexName = collection.createIndex(descendingIndex)
+        println(indexName)
+        // :snippet-end:
+        assertEquals("capacity_-1", indexName)
+    }
+
+    @Test
+    fun compoundIndexExampleTest() = runBlocking {
+        // :snippet-start: compound-index
+        val compoundIndexExample = Indexes.compoundIndex(
+            Indexes.descending("capacity", "year"),
+            Indexes.ascending("name")
+        )
+        val indexName = collection.createIndex(compoundIndexExample)
+        println(indexName)
+        // :snippet-end:
+        assertEquals("capacity_-1_year_-1_name_1", indexName)
+    }
+
+    @Test
+    fun textIndexTest() = runBlocking {
+        // :snippet-start: text-index
+        val textIndex = Indexes.text("theaters")
+        val indexName = collection.createIndex(textIndex)
+        println(indexName)
+        // :snippet-end:
+        assertEquals("theaters_text", indexName)
+    }
+
+    @Test
+    fun hashedIndexTest() = runBlocking {
+        // :snippet-start: hashed-index
+        val hashedIndex = Indexes.hashed("capacity")
+        val indexName = collection.createIndex(hashedIndex)
+        println(indexName)
+        // :snippet-end:
+        assertEquals("capacity_hashed", indexName)
+    }
+
+    @Test
+    fun geo2dsphereIndexTest() = runBlocking {
+        // :snippet-start: geo2dsphere-index
+        val geo2dsphereIndex = Indexes.geo2dsphere("location")
+        val indexName = collection.createIndex(geo2dsphereIndex)
+        println(indexName)
+        // :snippet-end:
+        assertEquals("location_2dsphere", indexName)
+    }
+}