DOCSP-30482: remove wildcard imports (#111)

# Pull Request Info

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

JIRA - https://jira.mongodb.org/browse/DOCSP-30482

**[staging](https://docs-mongodbcom-staging.corp.mongodb.com/kotlin/docsworker-xlarge/DOCSP-30482-remove-wildcards/)**

## Self-Review Checklist

- [x] 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?

(cherry picked from commit 1841195)

Author: rustagir

examples/src/test/kotlin/AggExpressionsTest.kt

@@ -3,7 +3,11 @@ import com.mongodb.client.model.Aggregates
 import com.mongodb.client.model.Field
 import com.mongodb.client.model.Filters
 import com.mongodb.client.model.Projections
-import com.mongodb.client.model.mql.*
+import com.mongodb.client.model.mql.MqlArray
+import com.mongodb.client.model.mql.MqlDocument
+import com.mongodb.client.model.mql.MqlInteger
+import com.mongodb.client.model.mql.MqlNumber
+import com.mongodb.client.model.mql.MqlString
 import com.mongodb.client.model.mql.MqlValues.current
 import com.mongodb.client.model.mql.MqlValues.of
 import com.mongodb.kotlin.client.coroutine.MongoClient

examples/src/test/kotlin/AggregatesBuilderTest.kt

@@ -1,9 +1,24 @@
 
 import com.mongodb.MongoNamespace
-import com.mongodb.client.model.*
-import com.mongodb.client.model.Accumulators.*
-import com.mongodb.client.model.Aggregates.*
-import com.mongodb.client.model.Sorts.ascending
+import com.mongodb.client.model.Accumulators
+import com.mongodb.client.model.Aggregates
+import com.mongodb.client.model.BucketAutoOptions
+import com.mongodb.client.model.BucketGranularity
+import com.mongodb.client.model.BucketOptions
+import com.mongodb.client.model.Facet
+import com.mongodb.client.model.Field
+import com.mongodb.client.model.Filters
+import com.mongodb.client.model.GraphLookupOptions
+import com.mongodb.client.model.IndexOptions
+import com.mongodb.client.model.Indexes
+import com.mongodb.client.model.MergeOptions
+import com.mongodb.client.model.MongoTimeUnit
+import com.mongodb.client.model.Projections
+import com.mongodb.client.model.Sorts
+import com.mongodb.client.model.UnwindOptions
+import com.mongodb.client.model.Variable
+import com.mongodb.client.model.WindowOutputFields
+import com.mongodb.client.model.Windows
 import com.mongodb.client.model.densify.DensifyOptions
 import com.mongodb.client.model.densify.DensifyRange
 import com.mongodb.client.model.fill.FillOptions
@@ -21,7 +36,10 @@ import kotlinx.coroutines.runBlocking
 import org.bson.Document
 import org.bson.codecs.pojo.annotations.BsonId
 import org.bson.types.ObjectId
-import org.junit.jupiter.api.*
+import org.junit.jupiter.api.AfterAll
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
 import java.time.LocalDateTime
 import kotlin.test.Ignore
 import kotlin.test.assertEquals
@@ -116,8 +134,8 @@ class AggregatesBuilderTest {
         val collection = database.getCollection<Document>("someCollection")
         collection.insertOne(Document("someField", "someCriteria"))
         // :snippet-start: methods-example
-        val matchStage = match(Filters.eq("someField", "someCriteria"))
-        val sortByCountStage = sortByCount("\$someField")
+        val matchStage = Aggregates.match(Filters.eq("someField", "someCriteria"))
+        val sortByCountStage = Aggregates.sortByCount("\$someField")
         val results = collection.aggregate(
             listOf(matchStage, sortByCountStage)).toList()
         // :snippet-end:
@@ -338,8 +356,8 @@ class AggregatesBuilderTest {
         val grouping = orderCollection.aggregate<Results>(listOf(
             // :snippet-start: group
             Aggregates.group("\$${Order::customerId.name}",
-                sum("totalQuantity", "\$${Order::ordered.name}"),
-                avg("averageQuantity", "\$${Order::ordered.name}")
+                Accumulators.sum("totalQuantity", "\$${Order::ordered.name}"),
+                Accumulators.avg("averageQuantity", "\$${Order::ordered.name}")
             )
             // :snippet-end:
         ))
@@ -673,7 +691,7 @@ class AggregatesBuilderTest {
 
         val resultsFlow = translateCollection.aggregate<Results>(listOf(
             // :snippet-start: replace-root
-            replaceRoot("\$${Book::spanishTranslation.name}")
+            Aggregates.replaceRoot("\$${Book::spanishTranslation.name}")
             //  :snippet-end:
 
         ))
@@ -686,7 +704,7 @@ class AggregatesBuilderTest {
         data class Results (val watched: Boolean, val type: String)
         val resultsFlow = movieCollection.aggregate<Results>(listOf(
             // :snippet-start: add-fields
-            addFields(
+            Aggregates.addFields(
                 Field("watched", false),
                 Field("type", "movie")
             )
@@ -711,7 +729,7 @@ class AggregatesBuilderTest {
     fun bucketTest() = runBlocking {
         val resultsFlow = screenCollection.aggregate<Document>(listOf(
             // :snippet-start: bucket
-            bucket("\$${Screen::screenSize.name}", listOf(0, 24, 32, 50, 70, 1000))
+            Aggregates.bucket("\$${Screen::screenSize.name}", listOf(0, 24, 32, 50, 70, 1000))
             // :snippet-end:
         ))
         assertEquals(4, resultsFlow.toList().size)
@@ -722,12 +740,12 @@ class AggregatesBuilderTest {
         data class Results(val count: Int, val matches: List<Int>)
         val resultsFlow = screenCollection.aggregate<Results>(listOf(
             // :snippet-start: bucket-options
-            bucket("\$${Screen::screenSize.name}", listOf(0, 24, 32, 50, 70),
+            Aggregates.bucket("\$${Screen::screenSize.name}", listOf(0, 24, 32, 50, 70),
                 BucketOptions()
                     .defaultBucket("monster")
                     .output(
-                        sum("count", 1),
-                        push("matches", "\$${Screen::screenSize.name}")
+                        Accumulators.sum("count", 1),
+                        Accumulators.push("matches", "\$${Screen::screenSize.name}")
                     )
             )
             // :snippet-end:
@@ -741,7 +759,7 @@ class AggregatesBuilderTest {
         data class Results(@BsonId val id: MinMax, val count: Int)
         val resultsFlow = screenCollection.aggregate<Results>(listOf(
             // :snippet-start: bucket-auto
-            bucketAuto("\$${Screen::screenSize.name}", 5)
+            Aggregates.bucketAuto("\$${Screen::screenSize.name}", 5)
             // :snippet-end:
         ))
         assertEquals(5, resultsFlow.toList().size)
@@ -755,11 +773,11 @@ class AggregatesBuilderTest {
         // example kotlin nested data classes
         val resultsFlow = screenCollection.aggregate<Results>(listOf(
             // :snippet-start: bucket-auto-options
-            bucketAuto(
+            Aggregates.bucketAuto(
                 "\$${Screen::price.name}", 5,
                 BucketAutoOptions()
                     .granularity(BucketGranularity.POWERSOF2)
-                    .output(sum("count", 1), avg("avgPrice", "\$${Screen::price.name}"))
+                    .output(Accumulators.sum("count", 1), Accumulators.avg("avgPrice", "\$${Screen::price.name}"))
                     )
             // :snippet-end:
         ))
@@ -774,19 +792,19 @@ class AggregatesBuilderTest {
         data class Results(val `Screen Sizes`: List<ScreenSize>)
         val resultsFlow = screenCollection.aggregate<Results>(listOf(
             // :snippet-start: facet
-            facet(
+            Aggregates.facet(
                 Facet(
                     "Screen Sizes",
-                    bucketAuto(
+                    Aggregates.bucketAuto(
                         "\$${Screen::screenSize.name}",
                         5,
-                        BucketAutoOptions().output(sum("count", 1))
+                        BucketAutoOptions().output(Accumulators.sum("count", 1))
                     )
                 ),
                 Facet(
                     "Manufacturer",
-                    sortByCount("\$${Screen::manufacturer.name}"),
-                    limit(5)
+                    Aggregates.sortByCount("\$${Screen::manufacturer.name}"),
+                    Aggregates.limit(5)
                 )
             )
             // :snippet-end:
@@ -852,7 +870,7 @@ class AggregatesBuilderTest {
         val resultsFlow = weatherCollection.aggregate<Weather>(
             listOf(
                 Aggregates.fill(
-                    FillOptions.fillOptions().sortBy(ascending(Weather::hour.name)),
+                    FillOptions.fillOptions().sortBy(Sorts.ascending(Weather::hour.name)),
                     FillOutputField.value(Weather::temperature.name, "23.6C"),
                     FillOutputField.linear(Weather::air_pressure.name)
                 )
@@ -881,7 +899,7 @@ class AggregatesBuilderTest {
         weatherCollection.insertMany(weather)
         val resultsFlow = weatherCollection.aggregate<Document>(listOf(
             // :snippet-start: densify
-            densify(
+            Aggregates.densify(
                 "ts",
                 DensifyRange.partitionRangeWithStep(15, MongoTimeUnit.MINUTE),
                 DensifyOptions.densifyOptions().partitionByFields("Position.coordinates")

examples/src/test/kotlin/AuthTest.kt

@@ -1,13 +1,17 @@
 
-import com.mongodb.*
+import com.mongodb.AwsCredential
+import com.mongodb.ConnectionString
+import com.mongodb.MongoClientSettings
+import com.mongodb.MongoCredential
+import com.mongodb.MongoException
+import com.mongodb.ServerAddress
 import com.mongodb.connection.ClusterSettings
 import com.mongodb.kotlin.client.coroutine.MongoClient
 import io.github.cdimascio.dotenv.dotenv
 import kotlinx.coroutines.runBlocking
 import org.bson.BsonInt64
 import org.bson.Document
 import org.junit.jupiter.api.TestInstance
-import java.util.*
 import java.util.function.Supplier
 import kotlin.test.Ignore
 

examples/src/test/kotlin/BuildersTest.kt

@@ -1,7 +1,6 @@
 
-import com.mongodb.*
-import com.mongodb.client.model.Filters.*
-import com.mongodb.client.model.Projections.*
+import com.mongodb.client.model.Filters
+import com.mongodb.client.model.Projections
 import com.mongodb.kotlin.client.coroutine.MongoClient
 import config.getConfig
 import kotlinx.coroutines.flow.first
@@ -10,11 +9,10 @@ import org.bson.BsonObjectId
 import org.bson.Document
 import org.bson.codecs.pojo.annotations.BsonId
 import org.junit.jupiter.api.AfterAll
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.util.*
-import kotlin.test.*
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 internal class BuildersTest {
@@ -75,8 +73,8 @@ internal class BuildersTest {
         // :snippet-start: builders
         data class Results(val email: String)
 
-        val filter = and(eq(User::gender.name, "female"), gt(User::age.name, 29))
-        val projection = fields(excludeId(), include("email"))
+        val filter = Filters.and(Filters.eq(User::gender.name, "female"), Filters.gt(User::age.name, 29))
+        val projection = Projections.fields(Projections.excludeId(), Projections.include("email"))
         val results = collection.find<Results>(filter).projection(projection)
         // :snippet-end:
         assertEquals("[email protected]", results.first().email)

examples/src/test/kotlin/BulkTest.kt

@@ -1,17 +1,25 @@
 
 import com.mongodb.MongoBulkWriteException
-import com.mongodb.client.model.*
+import com.mongodb.client.model.BulkWriteOptions
+import com.mongodb.client.model.DeleteManyModel
+import com.mongodb.client.model.DeleteOneModel
+import com.mongodb.client.model.Filters
+import com.mongodb.client.model.InsertOneModel
+import com.mongodb.client.model.ReplaceOneModel
+import com.mongodb.client.model.UpdateOneModel
+import com.mongodb.client.model.Updates
 import com.mongodb.kotlin.client.coroutine.MongoClient
 import config.getConfig
 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.*
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.util.*
-import kotlin.test.*
 
 // :snippet-start: bulk-data-model
 data class Person(

examples/src/test/kotlin/ChangeStreamsTest.kt

@@ -16,12 +16,12 @@ import kotlinx.coroutines.runBlocking
 import org.bson.Document
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.AfterEach
-import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.util.*
-import kotlin.test.*
-
+import java.util.UUID
+import kotlin.test.assertEquals
+import kotlin.test.Ignore
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 internal class ChangeStreamsTest {

examples/src/test/kotlin/ChangeTest.kt

@@ -6,11 +6,10 @@ import config.getConfig
 import kotlinx.coroutines.runBlocking
 import org.bson.codecs.pojo.annotations.BsonId
 import org.junit.jupiter.api.AfterAll
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.util.*
-import kotlin.test.*
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 internal class ChangeTest {

examples/src/test/kotlin/CodecTest.kt

@@ -7,7 +7,11 @@ import kotlinx.coroutines.runBlocking
 import org.bson.BsonReader
 import org.bson.BsonType
 import org.bson.BsonWriter
-import org.bson.codecs.*
+import org.bson.codecs.BsonTypeClassMap
+import org.bson.codecs.Codec
+import org.bson.codecs.DecoderContext
+import org.bson.codecs.EncoderContext
+import org.bson.codecs.IntegerCodec
 import org.bson.codecs.configuration.CodecProvider
 import org.bson.codecs.configuration.CodecRegistries
 import org.bson.codecs.configuration.CodecRegistry

examples/src/test/kotlin/CollationsTest.kt

@@ -1,5 +1,20 @@
 
-import com.mongodb.client.model.*
+import com.mongodb.client.model.Accumulators
+import com.mongodb.client.model.Aggregates
+import com.mongodb.client.model.Collation
+import com.mongodb.client.model.CollationAlternate
+import com.mongodb.client.model.CollationCaseFirst
+import com.mongodb.client.model.CollationMaxVariable
+import com.mongodb.client.model.CollationStrength
+import com.mongodb.client.model.CreateCollectionOptions
+import com.mongodb.client.model.Filters
+import com.mongodb.client.model.FindOneAndDeleteOptions
+import com.mongodb.client.model.FindOneAndUpdateOptions
+import com.mongodb.client.model.IndexOptions
+import com.mongodb.client.model.Indexes
+import com.mongodb.client.model.ReturnDocument
+import com.mongodb.client.model.Sorts
+import com.mongodb.client.model.Updates
 import com.mongodb.kotlin.client.coroutine.MongoClient
 import config.getConfig
 import kotlinx.coroutines.flow.first

examples/src/test/kotlin/CompoundTest.kt

@@ -1,19 +1,25 @@
 
-import com.mongodb.client.model.*
-import com.mongodb.client.model.Sorts.*
+import com.mongodb.client.model.Filters
+import com.mongodb.client.model.FindOneAndDeleteOptions
+import com.mongodb.client.model.FindOneAndReplaceOptions
+import com.mongodb.client.model.FindOneAndUpdateOptions
+import com.mongodb.client.model.ReturnDocument
+import com.mongodb.client.model.Sorts
+import com.mongodb.client.model.Updates
 import com.mongodb.kotlin.client.coroutine.MongoClient
 import config.getConfig
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.runBlocking
 import org.bson.codecs.pojo.annotations.BsonId
-import org.junit.jupiter.api.*
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.AfterAll
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import java.util.*
+import org.junit.jupiter.api.TestInstance
 import java.util.concurrent.TimeUnit
-import kotlin.test.*
-
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 internal class CompoundOperationsTest {
     // :snippet-start: compound-data-model