├── .editorconfig ├── .github ├── config.yml ├── stale.yml └── workflows │ ├── PR.yml │ ├── master.yml │ └── release.yml ├── .gitignore ├── LICENSE ├── README.md ├── build.gradle.kts ├── buildSrc ├── build.gradle.kts ├── settings.gradle.kts └── src │ └── main │ └── kotlin │ ├── Ci.kt │ └── kotest-publishing-conventions.gradle.kts ├── gradle.properties ├── gradle ├── libs.versions.toml └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── kotest-extensions-testcontainers-elastic ├── build.gradle.kts └── src │ ├── main │ └── kotlin │ │ └── io │ │ └── kotest │ │ └── extensions │ │ └── testcontainers │ │ └── elastic │ │ └── ElasticsearchContainerExtension.kt │ └── test │ └── kotlin │ └── io │ └── kotest │ └── extensions │ └── testcontainers │ └── elastic │ └── ElasticTestContainerExtensionTest.kt ├── kotest-extensions-testcontainers-kafka ├── build.gradle.kts └── src │ ├── main │ └── kotlin │ │ └── io │ │ └── kotest │ │ └── extensions │ │ └── testcontainers │ │ └── kafka │ │ └── KafkaContainerExtension.kt │ └── test │ └── kotlin │ └── io │ └── kotest │ └── extensions │ └── testcontainers │ └── kafka │ └── KafkaTestContainerExtensionTest.kt ├── renovate.json ├── settings.gradle.kts └── src ├── main └── kotlin │ └── io │ └── kotest │ └── extensions │ └── testcontainers │ ├── AbstractContainerExtension.kt │ ├── ContainerExtension.kt │ ├── ContainerLifecycleMode.kt │ ├── DockerComposeContainerExtension.kt │ ├── Extensions.kt │ ├── JdbcDatabaseContainerExtension.kt │ ├── SettableDataSource.kt │ ├── StartablePerProjectListener.kt │ ├── StartablePerSpecListener.kt │ ├── StartablePerTestListener.kt │ └── TestLifecycleAwareListener.kt └── test ├── kotlin └── io │ └── kotest │ └── extensions │ └── testcontainers │ ├── ContainerExtensionSpecLifecycleTest.kt │ ├── DockerComposeContainerExtensionTest.kt │ ├── JdbcDatabaseContainerExtensionSpecTest.kt │ ├── JdbcMultiScriptContainerInitTest.kt │ ├── SharedJdbcDatabaseContainerExtensionTest.kt │ ├── SharedTestContainerExtensionTest.kt │ ├── StartableTestLifecycleAware.kt │ ├── StartableTestLifecycleAwareTest.kt │ ├── TestContainerIntegrationPerSpec.kt │ ├── TestContainerIntegrationPerTest.kt │ ├── TestLifecycleAwareListenerTest.kt │ └── TestStartable.kt └── resources ├── docker-compose └── docker-compose.yml ├── init.sql └── sql-changesets ├── 001-people.sql └── 002-places.sql /.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*] 4 | 5 | indent_style = space 6 | indent_size = 3 7 | max_line_length = 120 8 | 9 | trim_trailing_whitespace = true 10 | insert_final_newline = true 11 | 12 | [*.gradle.kts] 13 | indent_size = 3 14 | -------------------------------------------------------------------------------- /.github/config.yml: -------------------------------------------------------------------------------- 1 | todo: 2 | keyword: "// todo" 3 | -------------------------------------------------------------------------------- /.github/stale.yml: -------------------------------------------------------------------------------- 1 | # Number of days of inactivity before an issue becomes stale 2 | daysUntilStale: 60 3 | # Number of days of inactivity before a stale issue is closed 4 | daysUntilClose: 7 5 | # Issues with these labels will never be considered stale 6 | exemptLabels: 7 | - pinned 8 | - security 9 | # Label to use when marking an issue as stale 10 | staleLabel: wontfix 11 | # Comment to post when marking an issue as stale. Set to `false` to disable 12 | markComment: > 13 | This issue has been automatically marked as stale because it has not had 14 | recent activity. It will be closed if no further activity occurs. Thank you 15 | for your contributions. 16 | # Comment to post when closing a stale issue. Set to `false` to disable 17 | closeComment: false 18 | -------------------------------------------------------------------------------- /.github/workflows/PR.yml: -------------------------------------------------------------------------------- 1 | name: PR-Test 2 | 3 | on: 4 | pull_request: 5 | paths-ignore: 6 | - '*.md' 7 | - '*.yml' 8 | 9 | jobs: 10 | build: 11 | runs-on: ubuntu-latest 12 | 13 | steps: 14 | - name: Checkout the repo 15 | uses: actions/checkout@v3 16 | 17 | - name: Setup JDK 18 | uses: actions/setup-java@v3 19 | with: 20 | java-version: '11' 21 | distribution: 'zulu' 22 | 23 | - name: Run tests 24 | run: ./gradlew check 25 | 26 | - name: Bundle the build report 27 | if: failure() 28 | run: find . -type d -name 'reports' | zip -@ -r build-reports.zip 29 | 30 | - name: Upload the build report 31 | if: failure() 32 | uses: actions/upload-artifact@master 33 | with: 34 | name: error-report 35 | path: build-reports.zip 36 | 37 | env: 38 | GRADLE_OPTS: -Dorg.gradle.configureondemand=true -Dorg.gradle.parallel=false -Dkotlin.incremental=false -Dorg.gradle.jvmargs="-Xmx3g -XX:MaxPermSize=2048m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8" 39 | -------------------------------------------------------------------------------- /.github/workflows/master.yml: -------------------------------------------------------------------------------- 1 | name: master 2 | 3 | on: 4 | push: 5 | paths-ignore: 6 | - '*.md' 7 | - '*.yml' 8 | branches: 9 | - master 10 | 11 | jobs: 12 | build: 13 | runs-on: ubuntu-latest 14 | steps: 15 | - name: Checkout the repo 16 | uses: actions/checkout@v3 17 | with: 18 | fetch-depth: 0 19 | 20 | - name: Setup JDK 21 | uses: actions/setup-java@v3 22 | with: 23 | java-version: '11' 24 | distribution: 'zulu' 25 | 26 | - name: Run tests 27 | run: ./gradlew check 28 | 29 | - name: publish snapshots 30 | run: ./gradlew publish 31 | env: 32 | OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }} 33 | OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }} 34 | ORG_GRADLE_PROJECT_signingKey: ${{ secrets.SIGNING_KEY }} 35 | ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.SIGNING_PASSWORD }} 36 | 37 | - name: Bundle the build report 38 | if: failure() 39 | run: find . -type d -name 'reports' | zip -@ -r build-reports.zip 40 | 41 | - name: Upload the build report 42 | if: failure() 43 | uses: actions/upload-artifact@master 44 | with: 45 | name: error-report 46 | path: build-reports.zip 47 | 48 | 49 | env: 50 | GRADLE_OPTS: -Dorg.gradle.configureondemand=true -Dorg.gradle.parallel=false -Dkotlin.incremental=false -Dorg.gradle.jvmargs="-Xmx3g -XX:MaxPermSize=2048m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8" 51 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | name: release 2 | 3 | on: 4 | workflow_dispatch: 5 | inputs: 6 | version: 7 | description: "The release version" 8 | required: true 9 | branch: 10 | description: "The branch to release from" 11 | required: true 12 | default: 'master' 13 | 14 | jobs: 15 | publish: 16 | runs-on: ubuntu-latest 17 | 18 | steps: 19 | - name: Checkout the repo 20 | uses: actions/checkout@v3 21 | with: 22 | fetch-depth: 0 23 | ref: ${{ github.event.inputs.branch }} 24 | 25 | - name: Setup JDK 26 | uses: actions/setup-java@v3 27 | with: 28 | java-version: '11' 29 | distribution: 'zulu' 30 | 31 | - name: deploy to sonatype 32 | run: ./gradlew publish 33 | env: 34 | RELEASE_VERSION: ${{ github.event.inputs.version }} 35 | OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }} 36 | OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }} 37 | ORG_GRADLE_PROJECT_signingKey: ${{ secrets.SIGNING_KEY }} 38 | ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.SIGNING_PASSWORD }} 39 | 40 | env: 41 | GRADLE_OPTS: -Dorg.gradle.configureondemand=true -Dorg.gradle.parallel=false -Dkotlin.incremental=false -Dorg.gradle.jvmargs="-Xmx3g -XX:MaxPermSize=2048m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8" 42 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | *.log 3 | .idea 4 | *.iml 5 | .kotlintest 6 | .gradle 7 | 8 | target/ 9 | build/ 10 | /build/ 11 | out/ 12 | lib_managed/ 13 | src_managed/ 14 | project/boot/ 15 | project/plugins/project/ 16 | credentials.sbt 17 | /.idea/ 18 | .DS_Store 19 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # kotest-extensions-testcontainers 2 | 3 | ## This project has moved to the main Kotest repo https://github.com/kotest/kotest 4 | 5 | Kotest extensions for [TestContainers](https://www.testcontainers.org/). 6 | 7 | See [docs](https://kotest.io/docs/extensions/test_containers.html). 8 | 9 | Please create issues on the main kotest [board](https://github.com/kotest/kotest/issues). 10 | 11 | [![Build Status](https://github.com/kotest/kotest-extensions-testcontainers/workflows/master/badge.svg)](https://github.com/kotest/kotest-extensions-testcontainers/actions) 12 | [](http://search.maven.org/#search|ga|1|kotest-extensions-testcontainers) 13 | ![GitHub](https://img.shields.io/github/license/kotest/kotest-extensions-testcontainers) 14 | [![kotest @ kotlinlang.slack.com](https://img.shields.io/static/v1?label=kotlinlang&message=kotest&color=blue&logo=slack)](https://kotlinlang.slack.com/archives/CT0G9SD7Z) 15 | [](https://s01.oss.sonatype.org/content/repositories/snapshots/io/kotest/extensions/kotest-extensions-testcontainers/) 16 | 17 | ## Compatibility 18 | 19 | Starting with version 1.3.4, the minimum Java version is 11. 20 | 21 | | Extension version | Min. Java version | 22 | |-------------------|-------------------| 23 | | 1.3.3 | 8 | 24 | | 1.3.4 | 11 | 25 | | 2.0.0 | 11 | 26 | 27 | 28 | ## Changelog 29 | 30 | ### 3.0.0 31 | * Deleted all deprecations 32 | * Container is now receiver of `beforeStart`, `afterStart`, `beforeShutdown` and `afterShutdown` lifecycle hooks` 33 | * Bumped Gradle to 8.8 34 | 35 | ### 2.0.0 36 | 37 | * Deprecated older extensions and introduced `JdbcDatabaseContainerExtension` and `ContainerExtension` extensions 38 | * Deprecated Kafka extensions in favour of the `kotest-extensions-testcontainers-kafka` module 39 | * Added kafka container `.producer()`, `.consumer()` and `.admin()` extension methods for opening producers, consumers and admin clients. 40 | * Added `DockerComposeContainerExtension` for executing test containers from docker compose files. 41 | * Added `kotest-extensions-testcontainers-elastic` and `kotest-extensions-testcontainers-localstack` 42 | * Deprecated per-test lifecycle modes 43 | * Deprecated custom SQL runner in favour of Flyway or another widely used db migration framework. 44 | 45 | ### 1.3.4 46 | 47 | * 5.4.0 compatibility 48 | 49 | ### 1.3.3 50 | 51 | * Version updates 52 | 53 | ### 1.3.2 54 | 55 | * Updated spec and test callbacks to be suspendable. 56 | 57 | ### 1.3.1 58 | 59 | * Updated test containers to 1.17.0 60 | 61 | ### 1.3.0 62 | 63 | * Added `SharedJdbcDatabaseContainerExtension` and `SharedTestContainerExtension` which can be used to lazily share a single test container across a module. 64 | 65 | ### 1.2.1 66 | 67 | * Improves the handling of `dbInitScripts`. Will now accept absolute or relative paths, for local _or classpath_ resources. 68 | 69 | ### 1.2.0 70 | 71 | * Adds new config option `dbInitScripts` on the `JdbcTestContainerExtension` config lambda. This option accepts a **list** 72 | of `.sql` files or folders (with .sql files, sorted lexicographically) to run after the container is started. 73 | ### 1.1.0 74 | 75 | * Requires Kotest 5.0.2 or higher 76 | * Adds `JdbcTestContainerExtension` as a new extension 77 | * Adds `TestContainerExtension` as a new extension 78 | 79 | ### 1.0.1 80 | 81 | * Released for test containers v1.16.0 82 | 83 | ### 1.0.0 84 | 85 | * Migrated from the main Kotest repo to a standalone repo. 86 | -------------------------------------------------------------------------------- /build.gradle.kts: -------------------------------------------------------------------------------- 1 | import org.gradle.api.tasks.testing.logging.TestExceptionFormat 2 | 3 | plugins { 4 | id("kotest-publishing-conventions") 5 | kotlin("jvm") version "1.6.21" 6 | } 7 | 8 | allprojects { 9 | apply(plugin = "org.jetbrains.kotlin.jvm") 10 | 11 | repositories { 12 | mavenCentral() 13 | maven { 14 | url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/") 15 | } 16 | } 17 | 18 | group = "io.kotest.extensions" 19 | version = Ci.version 20 | 21 | tasks.named("test") { 22 | useJUnitPlatform() 23 | testLogging { 24 | showExceptions = true 25 | showStandardStreams = true 26 | exceptionFormat = TestExceptionFormat.FULL 27 | } 28 | } 29 | 30 | tasks.withType { 31 | kotlinOptions.jvmTarget = "11" 32 | } 33 | } 34 | 35 | dependencies { 36 | implementation(libs.kotest.framework.api) 37 | implementation(libs.kotlinx.coroutines.core) 38 | api(libs.testcontainers.core) 39 | api(libs.testcontainers.jdbc) 40 | api(libs.testcontainers.kafka) 41 | api(libs.testcontainers.elastic) 42 | api(libs.kafka.client) 43 | api(libs.hikari) 44 | 45 | testImplementation(libs.logback) 46 | testImplementation(libs.kotest.assertions.core) 47 | testImplementation(libs.kotest.runner.junit5) 48 | testImplementation(libs.jedis) 49 | testImplementation(libs.testcontainers.mysql) 50 | testImplementation(libs.testcontainers.redis) 51 | testImplementation(libs.mysql.connector.java) 52 | } 53 | -------------------------------------------------------------------------------- /buildSrc/build.gradle.kts: -------------------------------------------------------------------------------- 1 | import org.jetbrains.kotlin.gradle.dsl.JvmTarget 2 | 3 | plugins { 4 | `kotlin-dsl` 5 | } 6 | 7 | kotlin { 8 | jvmToolchain(11) 9 | compilerOptions.jvmTarget.set(JvmTarget.JVM_11) 10 | } 11 | 12 | repositories { 13 | mavenCentral() 14 | } 15 | -------------------------------------------------------------------------------- /buildSrc/settings.gradle.kts: -------------------------------------------------------------------------------- 1 | rootProject.name="buildSrc" 2 | -------------------------------------------------------------------------------- /buildSrc/src/main/kotlin/Ci.kt: -------------------------------------------------------------------------------- 1 | object Ci { 2 | 3 | // this is the version used for building snapshots 4 | // .GITHUB_RUN_NUMBER-snapshot will be appended 5 | private const val snapshotBase = "3.0.0" 6 | 7 | private val githubRunNumber = System.getenv("GITHUB_RUN_NUMBER") 8 | 9 | private val snapshotVersion = when (githubRunNumber) { 10 | null -> "$snapshotBase-LOCAL" 11 | else -> "$snapshotBase.${githubRunNumber}-SNAPSHOT" 12 | } 13 | 14 | private val releaseVersion = System.getenv("RELEASE_VERSION") 15 | 16 | val isRelease = releaseVersion != null 17 | val version = releaseVersion ?: snapshotVersion 18 | } 19 | -------------------------------------------------------------------------------- /buildSrc/src/main/kotlin/kotest-publishing-conventions.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | `java-library` 3 | `maven-publish` 4 | signing 5 | } 6 | 7 | repositories { 8 | mavenCentral() 9 | } 10 | 11 | val signingKey: String? by project 12 | val signingPassword: String? by project 13 | 14 | fun Project.publishing(action: PublishingExtension.() -> Unit) = 15 | configure(action) 16 | 17 | fun Project.signing(configure: SigningExtension.() -> Unit): Unit = 18 | configure(configure) 19 | 20 | fun Project.java(configure: JavaPluginExtension.() -> Unit): Unit = 21 | configure(configure) 22 | 23 | 24 | val publications: PublicationContainer = (extensions.getByName("publishing") as PublishingExtension).publications 25 | 26 | signing { 27 | useGpgCmd() 28 | if (signingKey != null && signingPassword != null) { 29 | @Suppress("UnstableApiUsage") 30 | useInMemoryPgpKeys(signingKey, signingPassword) 31 | } 32 | if (Ci.isRelease) { 33 | sign(publications) 34 | } 35 | } 36 | 37 | java { 38 | withJavadocJar() 39 | withSourcesJar() 40 | } 41 | 42 | publishing { 43 | repositories { 44 | maven { 45 | val releasesRepoUrl = uri("https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/") 46 | val snapshotsRepoUrl = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/") 47 | name = "deploy" 48 | url = if (Ci.isRelease) releasesRepoUrl else snapshotsRepoUrl 49 | credentials { 50 | username = System.getenv("OSSRH_USERNAME") ?: "" 51 | password = System.getenv("OSSRH_PASSWORD") ?: "" 52 | } 53 | } 54 | } 55 | 56 | publications { 57 | register("mavenJava", MavenPublication::class) { 58 | from(components["java"]) 59 | pom { 60 | name.set("kotest-extensions-testcontainers") 61 | description.set("Kotest Extensions for Test Containers") 62 | url.set("http://www.github.com/kotest/kotest-extensions-testcontainers") 63 | 64 | scm { 65 | connection.set("scm:git:http://www.github.com/kotest/kotest-extensions-testcontainers") 66 | developerConnection.set("scm:git:http://github.com/sksamuel") 67 | url.set("http://www.github.com/kotest/kotest-extensions-testcontainers") 68 | } 69 | 70 | licenses { 71 | license { 72 | name.set("The Apache 2.0 License") 73 | url.set("https://opensource.org/licenses/Apache-2.0") 74 | } 75 | } 76 | 77 | developers { 78 | developer { 79 | id.set("sksamuel") 80 | name.set("Stephen Samuel") 81 | email.set("sam@sksamuel.com") 82 | } 83 | } 84 | } 85 | } 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | #https://github.com/gradle/gradle/issues/11308 2 | org.gradle.internal.publish.checksums.insecure=true 3 | systemProp.org.gradle.internal.publish.checksums.insecure=true 4 | org.gradle.parallel=true 5 | -------------------------------------------------------------------------------- /gradle/libs.versions.toml: -------------------------------------------------------------------------------- 1 | [versions] 2 | testcontainers = "1.19.8" 3 | kotest = "5.5.4" 4 | 5 | [libraries] 6 | kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version = "1.6.4" } 7 | hikari = { module = "com.zaxxer:HikariCP", version = "5.0.1" } 8 | jedis = { module = "redis.clients:jedis", version = "4.3.1" } 9 | mysql-connector-java = { module = "mysql:mysql-connector-java", version = "8.0.33" } 10 | kafka-client = { module = "org.apache.kafka:kafka-clients", version = "3.5.1" } 11 | elastic-client = { module = "co.elastic.clients:elasticsearch-java", version = "7.17.27" } 12 | logback = { module = "ch.qos.logback:logback-classic", version = "1.5.16" } 13 | 14 | testcontainers-elastic = { module = "org.testcontainers:elasticsearch", version.ref = "testcontainers" } 15 | testcontainers-mysql = { module = "org.testcontainers:mysql", version.ref = "testcontainers" } 16 | testcontainers-kafka = { module = "org.testcontainers:kafka", version.ref = "testcontainers" } 17 | testcontainers-jdbc = { module = "org.testcontainers:jdbc", version.ref = "testcontainers" } 18 | testcontainers-core = { module = "org.testcontainers:testcontainers", version.ref = "testcontainers" } 19 | testcontainers-redis = { module = "com.redis:testcontainers-redis", version = "1.7.0" } 20 | 21 | kotest-runner-junit5 = { module = "io.kotest:kotest-runner-junit5", version.ref = "kotest" } 22 | kotest-assertions-core = { module = "io.kotest:kotest-assertions-core", version.ref = "kotest" } 23 | kotest-framework-api = { module = "io.kotest:kotest-framework-api", version.ref = "kotest" } 24 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kotest/kotest-extensions-testcontainers/2bc02d7fed9c6f9e0c41e24719e2af88e9c4b53d/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip 4 | networkTimeout=10000 5 | validateDistributionUrl=true 6 | zipStoreBase=GRADLE_USER_HOME 7 | zipStorePath=wrapper/dists 8 | -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # 4 | # Copyright © 2015-2021 the original authors. 5 | # 6 | # Licensed under the Apache License, Version 2.0 (the "License"); 7 | # you may not use this file except in compliance with the License. 8 | # You may obtain a copy of the License at 9 | # 10 | # https://www.apache.org/licenses/LICENSE-2.0 11 | # 12 | # Unless required by applicable law or agreed to in writing, software 13 | # distributed under the License is distributed on an "AS IS" BASIS, 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | # See the License for the specific language governing permissions and 16 | # limitations under the License. 17 | # 18 | 19 | ############################################################################## 20 | # 21 | # Gradle start up script for POSIX generated by Gradle. 22 | # 23 | # Important for running: 24 | # 25 | # (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is 26 | # noncompliant, but you have some other compliant shell such as ksh or 27 | # bash, then to run this script, type that shell name before the whole 28 | # command line, like: 29 | # 30 | # ksh Gradle 31 | # 32 | # Busybox and similar reduced shells will NOT work, because this script 33 | # requires all of these POSIX shell features: 34 | # * functions; 35 | # * expansions «$var», «${var}», «${var:-default}», «${var+SET}», 36 | # «${var#prefix}», «${var%suffix}», and «$( cmd )»; 37 | # * compound commands having a testable exit status, especially «case»; 38 | # * various built-in commands including «command», «set», and «ulimit». 39 | # 40 | # Important for patching: 41 | # 42 | # (2) This script targets any POSIX shell, so it avoids extensions provided 43 | # by Bash, Ksh, etc; in particular arrays are avoided. 44 | # 45 | # The "traditional" practice of packing multiple parameters into a 46 | # space-separated string is a well documented source of bugs and security 47 | # problems, so this is (mostly) avoided, by progressively accumulating 48 | # options in "$@", and eventually passing that to Java. 49 | # 50 | # Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, 51 | # and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; 52 | # see the in-line comments for details. 53 | # 54 | # There are tweaks for specific operating systems such as AIX, CygWin, 55 | # Darwin, MinGW, and NonStop. 56 | # 57 | # (3) This script is generated from the Groovy template 58 | # https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt 59 | # within the Gradle project. 60 | # 61 | # You can find Gradle at https://github.com/gradle/gradle/. 62 | # 63 | ############################################################################## 64 | 65 | # Attempt to set APP_HOME 66 | 67 | # Resolve links: $0 may be a link 68 | app_path=$0 69 | 70 | # Need this for daisy-chained symlinks. 71 | while 72 | APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path 73 | [ -h "$app_path" ] 74 | do 75 | ls=$( ls -ld "$app_path" ) 76 | link=${ls#*' -> '} 77 | case $link in #( 78 | /*) app_path=$link ;; #( 79 | *) app_path=$APP_HOME$link ;; 80 | esac 81 | done 82 | 83 | # This is normally unused 84 | # shellcheck disable=SC2034 85 | APP_BASE_NAME=${0##*/} 86 | # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) 87 | APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit 88 | 89 | # Use the maximum available, or set MAX_FD != -1 to use that value. 90 | MAX_FD=maximum 91 | 92 | warn () { 93 | echo "$*" 94 | } >&2 95 | 96 | die () { 97 | echo 98 | echo "$*" 99 | echo 100 | exit 1 101 | } >&2 102 | 103 | # OS specific support (must be 'true' or 'false'). 104 | cygwin=false 105 | msys=false 106 | darwin=false 107 | nonstop=false 108 | case "$( uname )" in #( 109 | CYGWIN* ) cygwin=true ;; #( 110 | Darwin* ) darwin=true ;; #( 111 | MSYS* | MINGW* ) msys=true ;; #( 112 | NONSTOP* ) nonstop=true ;; 113 | esac 114 | 115 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 116 | 117 | 118 | # Determine the Java command to use to start the JVM. 119 | if [ -n "$JAVA_HOME" ] ; then 120 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 121 | # IBM's JDK on AIX uses strange locations for the executables 122 | JAVACMD=$JAVA_HOME/jre/sh/java 123 | else 124 | JAVACMD=$JAVA_HOME/bin/java 125 | fi 126 | if [ ! -x "$JAVACMD" ] ; then 127 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 128 | 129 | Please set the JAVA_HOME variable in your environment to match the 130 | location of your Java installation." 131 | fi 132 | else 133 | JAVACMD=java 134 | if ! command -v java >/dev/null 2>&1 135 | then 136 | die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 137 | 138 | Please set the JAVA_HOME variable in your environment to match the 139 | location of your Java installation." 140 | fi 141 | fi 142 | 143 | # Increase the maximum file descriptors if we can. 144 | if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then 145 | case $MAX_FD in #( 146 | max*) 147 | # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. 148 | # shellcheck disable=SC3045 149 | MAX_FD=$( ulimit -H -n ) || 150 | warn "Could not query maximum file descriptor limit" 151 | esac 152 | case $MAX_FD in #( 153 | '' | soft) :;; #( 154 | *) 155 | # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. 156 | # shellcheck disable=SC3045 157 | ulimit -n "$MAX_FD" || 158 | warn "Could not set maximum file descriptor limit to $MAX_FD" 159 | esac 160 | fi 161 | 162 | # Collect all arguments for the java command, stacking in reverse order: 163 | # * args from the command line 164 | # * the main class name 165 | # * -classpath 166 | # * -D...appname settings 167 | # * --module-path (only if needed) 168 | # * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. 169 | 170 | # For Cygwin or MSYS, switch paths to Windows format before running java 171 | if "$cygwin" || "$msys" ; then 172 | APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) 173 | CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) 174 | 175 | JAVACMD=$( cygpath --unix "$JAVACMD" ) 176 | 177 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 178 | for arg do 179 | if 180 | case $arg in #( 181 | -*) false ;; # don't mess with options #( 182 | /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath 183 | [ -e "$t" ] ;; #( 184 | *) false ;; 185 | esac 186 | then 187 | arg=$( cygpath --path --ignore --mixed "$arg" ) 188 | fi 189 | # Roll the args list around exactly as many times as the number of 190 | # args, so each arg winds up back in the position where it started, but 191 | # possibly modified. 192 | # 193 | # NB: a `for` loop captures its iteration list before it begins, so 194 | # changing the positional parameters here affects neither the number of 195 | # iterations, nor the values presented in `arg`. 196 | shift # remove old arg 197 | set -- "$@" "$arg" # push replacement arg 198 | done 199 | fi 200 | 201 | 202 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 203 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' 204 | 205 | # Collect all arguments for the java command; 206 | # * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of 207 | # shell script including quotes and variable substitutions, so put them in 208 | # double quotes to make sure that they get re-expanded; and 209 | # * put everything else in single quotes, so that it's not re-expanded. 210 | 211 | set -- \ 212 | "-Dorg.gradle.appname=$APP_BASE_NAME" \ 213 | -classpath "$CLASSPATH" \ 214 | org.gradle.wrapper.GradleWrapperMain \ 215 | "$@" 216 | 217 | # Stop when "xargs" is not available. 218 | if ! command -v xargs >/dev/null 2>&1 219 | then 220 | die "xargs is not available" 221 | fi 222 | 223 | # Use "xargs" to parse quoted args. 224 | # 225 | # With -n1 it outputs one arg per line, with the quotes and backslashes removed. 226 | # 227 | # In Bash we could simply go: 228 | # 229 | # readarray ARGS < <( xargs -n1 <<<"$var" ) && 230 | # set -- "${ARGS[@]}" "$@" 231 | # 232 | # but POSIX shell has neither arrays nor command substitution, so instead we 233 | # post-process each arg (as a line of input to sed) to backslash-escape any 234 | # character that might be a shell metacharacter, then use eval to reverse 235 | # that process (while maintaining the separation between arguments), and wrap 236 | # the whole thing up as a single "set" statement. 237 | # 238 | # This will of course break if any of these variables contains a newline or 239 | # an unmatched quote. 240 | # 241 | 242 | eval "set -- $( 243 | printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | 244 | xargs -n1 | 245 | sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | 246 | tr '\n' ' ' 247 | )" '"$@"' 248 | 249 | exec "$JAVACMD" "$@" 250 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @rem 2 | @rem Copyright 2015 the original author or authors. 3 | @rem 4 | @rem Licensed under the Apache License, Version 2.0 (the "License"); 5 | @rem you may not use this file except in compliance with the License. 6 | @rem You may obtain a copy of the License at 7 | @rem 8 | @rem https://www.apache.org/licenses/LICENSE-2.0 9 | @rem 10 | @rem Unless required by applicable law or agreed to in writing, software 11 | @rem distributed under the License is distributed on an "AS IS" BASIS, 12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | @rem See the License for the specific language governing permissions and 14 | @rem limitations under the License. 15 | @rem 16 | 17 | @if "%DEBUG%"=="" @echo off 18 | @rem ########################################################################## 19 | @rem 20 | @rem Gradle startup script for Windows 21 | @rem 22 | @rem ########################################################################## 23 | 24 | @rem Set local scope for the variables with windows NT shell 25 | if "%OS%"=="Windows_NT" setlocal 26 | 27 | set DIRNAME=%~dp0 28 | if "%DIRNAME%"=="" set DIRNAME=. 29 | @rem This is normally unused 30 | set APP_BASE_NAME=%~n0 31 | set APP_HOME=%DIRNAME% 32 | 33 | @rem Resolve any "." and ".." in APP_HOME to make it shorter. 34 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi 35 | 36 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 37 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" 38 | 39 | @rem Find java.exe 40 | if defined JAVA_HOME goto findJavaFromJavaHome 41 | 42 | set JAVA_EXE=java.exe 43 | %JAVA_EXE% -version >NUL 2>&1 44 | if %ERRORLEVEL% equ 0 goto execute 45 | 46 | echo. 47 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 48 | echo. 49 | echo Please set the JAVA_HOME variable in your environment to match the 50 | echo location of your Java installation. 51 | 52 | goto fail 53 | 54 | :findJavaFromJavaHome 55 | set JAVA_HOME=%JAVA_HOME:"=% 56 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 57 | 58 | if exist "%JAVA_EXE%" goto execute 59 | 60 | echo. 61 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 62 | echo. 63 | echo Please set the JAVA_HOME variable in your environment to match the 64 | echo location of your Java installation. 65 | 66 | goto fail 67 | 68 | :execute 69 | @rem Setup the command line 70 | 71 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 72 | 73 | 74 | @rem Execute Gradle 75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* 76 | 77 | :end 78 | @rem End local scope for the variables with windows NT shell 79 | if %ERRORLEVEL% equ 0 goto mainEnd 80 | 81 | :fail 82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 83 | rem the _cmd.exe /c_ return code! 84 | set EXIT_CODE=%ERRORLEVEL% 85 | if %EXIT_CODE% equ 0 set EXIT_CODE=1 86 | if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% 87 | exit /b %EXIT_CODE% 88 | 89 | :mainEnd 90 | if "%OS%"=="Windows_NT" endlocal 91 | 92 | :omega 93 | -------------------------------------------------------------------------------- /kotest-extensions-testcontainers-elastic/build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | id("kotest-publishing-conventions") 3 | } 4 | 5 | dependencies { 6 | implementation(projects.kotestExtensionsTestcontainers) 7 | implementation(libs.kotest.framework.api) 8 | implementation(libs.kotlinx.coroutines.core) 9 | api(libs.testcontainers.core) 10 | api(libs.testcontainers.elastic) 11 | api(libs.elastic.client) 12 | 13 | implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.15.2") 14 | implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.15.2") 15 | implementation("com.fasterxml.jackson.datatype:jackson-datatype-joda:2.17.2") 16 | 17 | testImplementation(libs.kotest.assertions.core) 18 | testImplementation(libs.kotest.runner.junit5) 19 | 20 | testImplementation("ch.qos.logback:logback-classic:1.5.16") 21 | testImplementation("org.slf4j:slf4j-api:2.0.16") 22 | } 23 | -------------------------------------------------------------------------------- /kotest-extensions-testcontainers-elastic/src/main/kotlin/io/kotest/extensions/testcontainers/elastic/ElasticsearchContainerExtension.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers.elastic 2 | 3 | import co.elastic.clients.elasticsearch.ElasticsearchClient 4 | import co.elastic.clients.json.jackson.JacksonJsonpMapper 5 | import co.elastic.clients.transport.rest_client.RestClientTransport 6 | import io.kotest.extensions.testcontainers.AbstractContainerExtension 7 | import io.kotest.extensions.testcontainers.ContainerLifecycleMode 8 | import org.apache.http.HttpHost 9 | import org.elasticsearch.client.RestClient 10 | import org.testcontainers.elasticsearch.ElasticsearchContainer 11 | import org.testcontainers.utility.DockerImageName 12 | 13 | class ElasticsearchContainerExtension( 14 | container: ElasticsearchContainer, 15 | mode: ContainerLifecycleMode = ContainerLifecycleMode.Project, 16 | ) : AbstractContainerExtension(container, mode) { 17 | 18 | constructor( 19 | image: DockerImageName, 20 | mode: ContainerLifecycleMode = ContainerLifecycleMode.Project 21 | ) : this(ElasticsearchContainer(image), mode) 22 | } 23 | 24 | fun ElasticsearchContainer.client(): ElasticsearchClient { 25 | val restClient = RestClient.builder(HttpHost.create(httpHostAddress)).build() 26 | val transport = RestClientTransport(restClient, JacksonJsonpMapper()) 27 | return ElasticsearchClient(transport) 28 | } 29 | -------------------------------------------------------------------------------- /kotest-extensions-testcontainers-elastic/src/test/kotlin/io/kotest/extensions/testcontainers/elastic/ElasticTestContainerExtensionTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers.elastic 2 | 3 | import co.elastic.clients.elasticsearch._types.Refresh 4 | import co.elastic.clients.elasticsearch.core.IndexRequest 5 | import co.elastic.clients.elasticsearch.core.SearchRequest 6 | import co.elastic.clients.elasticsearch.indices.CreateIndexRequest 7 | import io.kotest.core.extensions.install 8 | import io.kotest.core.spec.style.FunSpec 9 | import io.kotest.matchers.shouldBe 10 | import org.testcontainers.utility.DockerImageName 11 | 12 | class ElasticTestContainerExtensionTest : FunSpec() { 13 | init { 14 | 15 | val container = install( 16 | ElasticsearchContainerExtension( 17 | DockerImageName.parse("elasticsearch:7.17.6") 18 | .asCompatibleSubstituteFor("docker.elastic.co/elasticsearch/elasticsearch") 19 | ) 20 | ) 21 | 22 | val client = container.client() 23 | 24 | test("elastic happy path") { 25 | 26 | val create = CreateIndexRequest.Builder() 27 | .index("foo") 28 | .build() 29 | client.indices().create(create) 30 | 31 | val req = IndexRequest.Builder>() 32 | req.index("foo") 33 | req.id("123") 34 | req.document(mapOf("name" to "billy the butcher")) 35 | req.refresh(Refresh.True) 36 | 37 | client.index(req.build()) 38 | 39 | val sreq = SearchRequest.Builder().index("foo").build() 40 | client.search(sreq, Map::class.java).hits().hits().size shouldBe 1 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /kotest-extensions-testcontainers-kafka/build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | id("kotest-publishing-conventions") 3 | } 4 | 5 | dependencies { 6 | implementation(libs.kotest.framework.api) 7 | implementation(libs.kotlinx.coroutines.core) 8 | api(projects.kotestExtensionsTestcontainers) 9 | 10 | api(libs.testcontainers.core) 11 | api(libs.testcontainers.kafka) 12 | api(libs.kafka.client) 13 | 14 | testImplementation(libs.kotest.assertions.core) 15 | testImplementation(libs.kotest.runner.junit5) 16 | 17 | testImplementation("ch.qos.logback:logback-classic:1.5.16") 18 | testImplementation("org.slf4j:slf4j-api:2.0.16") 19 | } 20 | -------------------------------------------------------------------------------- /kotest-extensions-testcontainers-kafka/src/main/kotlin/io/kotest/extensions/testcontainers/kafka/KafkaContainerExtension.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers.kafka 2 | 3 | import io.kotest.extensions.testcontainers.AbstractContainerExtension 4 | import io.kotest.extensions.testcontainers.ContainerLifecycleMode 5 | import org.apache.kafka.clients.CommonClientConfigs 6 | import org.apache.kafka.clients.admin.Admin 7 | import org.apache.kafka.clients.admin.AdminClient 8 | import org.apache.kafka.clients.consumer.ConsumerConfig 9 | import org.apache.kafka.clients.consumer.KafkaConsumer 10 | import org.apache.kafka.clients.producer.KafkaProducer 11 | import org.apache.kafka.clients.producer.ProducerConfig 12 | import org.apache.kafka.common.serialization.BytesDeserializer 13 | import org.apache.kafka.common.serialization.BytesSerializer 14 | import org.apache.kafka.common.serialization.StringDeserializer 15 | import org.apache.kafka.common.serialization.StringSerializer 16 | import org.apache.kafka.common.utils.Bytes 17 | import org.testcontainers.containers.KafkaContainer 18 | import org.testcontainers.utility.DockerImageName 19 | import java.util.Properties 20 | 21 | class KafkaContainerExtension( 22 | container: KafkaContainer, 23 | mode: ContainerLifecycleMode = ContainerLifecycleMode.Project, 24 | ) : AbstractContainerExtension(container, mode) { 25 | 26 | constructor( 27 | image: DockerImageName, 28 | mode: ContainerLifecycleMode = ContainerLifecycleMode.Project 29 | ) : this(KafkaContainer(image), mode) 30 | } 31 | 32 | fun KafkaContainer.admin(configure: Properties.() -> Unit = {}): Admin { 33 | val props = Properties() 34 | props[CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG] = bootstrapServers 35 | props.configure() 36 | return Admin.create(props) 37 | } 38 | 39 | fun KafkaContainer.producer(configure: Properties.() -> Unit = {}): KafkaProducer { 40 | val props = Properties() 41 | props[CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG] = bootstrapServers 42 | props[ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG] = BytesSerializer::class.java 43 | props[ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG] = BytesSerializer::class.java 44 | props.configure() 45 | return KafkaProducer(props) 46 | } 47 | 48 | fun KafkaContainer.stringStringProducer(configure: Properties.() -> Unit = {}): KafkaProducer { 49 | val props = Properties() 50 | props[CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG] = bootstrapServers 51 | props[ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG] = StringSerializer::class.java 52 | props[ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG] = StringSerializer::class.java 53 | props.configure() 54 | return KafkaProducer(props) 55 | } 56 | 57 | fun KafkaContainer.consumer(configure: Properties.() -> Unit = {}): KafkaConsumer { 58 | val props = Properties() 59 | props[CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG] = bootstrapServers 60 | props[ConsumerConfig.GROUP_ID_CONFIG] = "kotest_consumer_" + System.currentTimeMillis() 61 | props[ConsumerConfig.AUTO_OFFSET_RESET_CONFIG] = "earliest" 62 | props[ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG] = BytesDeserializer::class.java 63 | props[ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG] = BytesDeserializer::class.java 64 | props.configure() 65 | return KafkaConsumer(props) 66 | } 67 | 68 | fun KafkaContainer.stringStringConsumer(configure: Properties.() -> Unit = {}): KafkaConsumer { 69 | val props = Properties() 70 | props[CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG] = bootstrapServers 71 | props[ConsumerConfig.GROUP_ID_CONFIG] = "kotest_consumer_" + System.currentTimeMillis() 72 | props[ConsumerConfig.AUTO_OFFSET_RESET_CONFIG] = "earliest" 73 | props[ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG] = StringDeserializer::class.java 74 | props[ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG] = StringDeserializer::class.java 75 | props.configure() 76 | return KafkaConsumer(props) 77 | } 78 | -------------------------------------------------------------------------------- /kotest-extensions-testcontainers-kafka/src/test/kotlin/io/kotest/extensions/testcontainers/kafka/KafkaTestContainerExtensionTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers.kafka 2 | 3 | import io.kotest.core.extensions.install 4 | import io.kotest.core.spec.style.FunSpec 5 | import io.kotest.matchers.shouldBe 6 | import org.apache.kafka.clients.producer.ProducerRecord 7 | import org.apache.kafka.common.utils.Bytes 8 | import org.testcontainers.utility.DockerImageName 9 | import java.time.Duration 10 | 11 | class KafkaTestContainerExtensionTest : FunSpec({ 12 | 13 | val container = install(KafkaContainerExtension(DockerImageName.parse("confluentinc/cp-kafka:5.4.3"))) 14 | 15 | test("happy path") { 16 | 17 | val producer = container.producer() 18 | producer.send(ProducerRecord("mytopic", Bytes("hello world".encodeToByteArray()))) 19 | producer.close() 20 | 21 | val consumer = container.consumer() 22 | consumer.subscribe(listOf("mytopic")) 23 | consumer.poll(Duration.ofSeconds(10)).toList().single().value().get().decodeToString() shouldBe "hello world" 24 | } 25 | 26 | }) 27 | -------------------------------------------------------------------------------- /renovate.json: -------------------------------------------------------------------------------- 1 | { 2 | "extends": [ 3 | "config:base", "github>kotest/renovate-config" 4 | ] 5 | } 6 | -------------------------------------------------------------------------------- /settings.gradle.kts: -------------------------------------------------------------------------------- 1 | rootProject.name = "kotest-extensions-testcontainers" 2 | 3 | pluginManagement { 4 | repositories { 5 | mavenCentral() 6 | gradlePluginPortal() 7 | } 8 | } 9 | 10 | include( 11 | ":kotest-extensions-testcontainers-kafka", 12 | ":kotest-extensions-testcontainers-elastic", 13 | ) 14 | 15 | enableFeaturePreview("STABLE_CONFIGURATION_CACHE") 16 | enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") 17 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/AbstractContainerExtension.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.extensions.MountableExtension 4 | import io.kotest.core.listeners.AfterProjectListener 5 | import io.kotest.core.listeners.AfterSpecListener 6 | import io.kotest.core.spec.Spec 7 | import org.testcontainers.containers.GenericContainer 8 | 9 | abstract class AbstractContainerExtension>( 10 | private val container: T, 11 | private val mode: ContainerLifecycleMode = ContainerLifecycleMode.Project, 12 | ) : AfterProjectListener, 13 | AfterSpecListener, 14 | MountableExtension, 15 | AutoCloseable { 16 | 17 | override fun mount(configure: T.() -> Unit): T { 18 | if (!container.isRunning) { 19 | container.configure() 20 | container.start() 21 | } 22 | return container 23 | } 24 | 25 | final override suspend fun afterProject() { 26 | if (container.isRunning) close() 27 | } 28 | 29 | final override suspend fun afterSpec(spec: Spec) { 30 | if (mode == ContainerLifecycleMode.Spec && container.isRunning) close() 31 | } 32 | 33 | final override fun close() { 34 | container.stop() 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/ContainerExtension.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.extensions.MountableExtension 4 | import io.kotest.core.listeners.AfterProjectListener 5 | import io.kotest.core.listeners.AfterSpecListener 6 | import io.kotest.core.listeners.AfterTestListener 7 | import io.kotest.core.listeners.BeforeSpecListener 8 | import io.kotest.core.listeners.BeforeTestListener 9 | import io.kotest.core.spec.Spec 10 | import io.kotest.core.test.TestCase 11 | import io.kotest.core.test.TestResult 12 | import kotlinx.coroutines.Dispatchers 13 | import kotlinx.coroutines.withContext 14 | import org.testcontainers.containers.GenericContainer 15 | 16 | /** 17 | * A Kotest [MountableExtension] for [GenericContainer]s that are started the first time they are 18 | * installed in a spec. 19 | * 20 | * If no spec is executed that installs a particular container, 21 | * then that container is never started. 22 | * 23 | * Containers can be shared between specs using the default [mode]. 24 | * 25 | * @param container the test container instance 26 | * 27 | * @param mode determines if the container is shutdown after the test suite (project) or after the installed spec 28 | * The default is after the test suite. 29 | * 30 | * @param beforeStart a callback that is invoked only once, just before the container is started. 31 | * If the container is never started, this callback will not be invoked. 32 | * This callback can be useful instead of the installation callback as it will only 33 | * be executed once, regardless of how many times this container is installed. 34 | * 35 | * @param afterStart a callback that is invoked only once, just after the container is started. 36 | * If the container is never started, this callback will not be invoked. 37 | * 38 | * @param beforeSpec a beforeSpec callback. 39 | * If the container is never started, this callback will not be invoked. 40 | * 41 | * @param afterSpec an afterSpec callback 42 | * If the container is never started, this callback will not be invoked. 43 | * 44 | * @param beforeTest a beforeTest callback 45 | * If the container is never started, this callback will not be invoked. 46 | * 47 | * @param afterTest a afterTest callback 48 | * If the container is never started, this callback will not be invoked. 49 | * 50 | * @param beforeShutdown a callback that is invoked only once, just before the container is stopped. 51 | * If the container is never started, this callback will not be invoked. 52 | * 53 | * @param afterShutdown a callback that is invoked only once, just after the container is stopped. 54 | * If the container is never started, this callback will not be invoked. 55 | */ 56 | class ContainerExtension>( 57 | private val container: T, 58 | private val mode: ContainerLifecycleMode = ContainerLifecycleMode.Project, 59 | private val beforeStart: T.() -> Unit = {}, 60 | private val afterStart: T.() -> Unit = {}, 61 | private val beforeTest: suspend (TestCase) -> Unit = { _ -> }, 62 | private val afterTest: suspend (TestCase) -> Unit = { _ -> }, 63 | private val beforeSpec: suspend (Spec) -> Unit = { _ -> }, 64 | private val afterSpec: suspend (Spec) -> Unit = { _ -> }, 65 | private val beforeShutdown: suspend T.() -> Unit = {}, 66 | private val afterShutdown: suspend T.() -> Unit = {}, 67 | ) : MountableExtension, 68 | AfterProjectListener, 69 | BeforeTestListener, 70 | BeforeSpecListener, 71 | AfterTestListener, 72 | AfterSpecListener { 73 | 74 | /** 75 | * Mounts the container, starting it if necessary. The [configure] block will be invoked 76 | * every time the [ContainerExtension] is mounted, before the container is started. 77 | */ 78 | override fun mount(configure: T.() -> Unit): T = container.apply{ 79 | configure() 80 | 81 | if (!isRunning) { 82 | beforeStart() 83 | start() 84 | afterStart() 85 | } 86 | } 87 | 88 | override suspend fun beforeTest(testCase: TestCase) { 89 | beforeTest.invoke(testCase) 90 | } 91 | 92 | override suspend fun afterTest(testCase: TestCase, result: TestResult) { 93 | afterTest(testCase) 94 | } 95 | 96 | override suspend fun beforeSpec(spec: Spec) { 97 | beforeSpec.invoke(spec) 98 | } 99 | 100 | override suspend fun afterSpec(spec: Spec) { 101 | afterSpec.invoke(spec) 102 | if (mode == ContainerLifecycleMode.Spec && container.isRunning) close() 103 | } 104 | 105 | override suspend fun afterProject() { 106 | if (container.isRunning) close() 107 | } 108 | 109 | private suspend fun close() { 110 | withContext(Dispatchers.IO) { 111 | container.beforeShutdown() 112 | container.stop() 113 | container.afterShutdown() 114 | } 115 | } 116 | } 117 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/ContainerLifecycleMode.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | /** 4 | * Determines the lifetime of a test container installed in a Kotest extension. 5 | */ 6 | enum class ContainerLifecycleMode { 7 | 8 | /** 9 | * The TestContainer is started only when first installed and stopped after the spec where it was 10 | * installed completes. 11 | * 12 | * Use this when you need the test container to shut down as soon as the spec does - usually 13 | * because you are using a separate test container per spec and waiting until the test suite 14 | * completes to shut them all down will take too much memory. 15 | */ 16 | Spec, 17 | 18 | /** 19 | * The TestContainer is started only when first installed and stopped after the entire test suite. 20 | * This mode is the default choice for test containers. This mode can be used with 21 | * multiple test containers by using separate instances of the container extensions. 22 | */ 23 | Project, 24 | } 25 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/DockerComposeContainerExtension.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.extensions.MountableExtension 4 | import io.kotest.core.listeners.AfterProjectListener 5 | import io.kotest.core.listeners.AfterSpecListener 6 | import io.kotest.core.listeners.AfterTestListener 7 | import io.kotest.core.listeners.BeforeSpecListener 8 | import io.kotest.core.listeners.BeforeTestListener 9 | import io.kotest.core.spec.Spec 10 | import io.kotest.core.test.TestCase 11 | import io.kotest.core.test.TestResult 12 | import kotlinx.coroutines.Dispatchers 13 | import kotlinx.coroutines.withContext 14 | import org.testcontainers.containers.DockerComposeContainer 15 | import org.testcontainers.containers.GenericContainer 16 | import java.io.File 17 | 18 | /** 19 | * A Kotest [MountableExtension] for [GenericContainer]s that are started the first time they are 20 | * installed in a spec. 21 | * 22 | * If no spec is executed that installs a particular container, 23 | * then that container is never started. 24 | * 25 | * Containers can be shared between specs using the default [mode]. 26 | * 27 | * @param container the test container instance 28 | * 29 | * @param mode determines if the container is shutdown after the test suite (project) or after the installed spec 30 | * The default is after the test suite. 31 | * 32 | * @param beforeSpec a beforeSpec callback 33 | * @param afterSpec an afterSpec callback 34 | * @param beforeTest a beforeTest callback 35 | * @param afterTest a afterTest callback 36 | * 37 | * @param beforeStart a callback that is invoked only once, just before the container is started. 38 | * If the container is never started, this callback will not be invoked. 39 | * This callback can be useful instead of the installation callback as it will only 40 | * be executed once, regardless of how many times this container is installed. 41 | * 42 | * @param afterStart a callback that is invoked only once, just after the container is started. 43 | * If the container is never started, this callback will not be invoked. 44 | * 45 | * @param beforeShutdown a callback that is invoked only once, just before the container is stopped. 46 | * If the container is never started, this callback will not be invoked. 47 | * 48 | * @param afterShutdown a callback that is invoked only once, just after the container is stopped. 49 | * If the container is never started, this callback will not be invoked. 50 | */ 51 | class DockerComposeContainerExtension>( 52 | private val container: T, 53 | private val mode: ContainerLifecycleMode = ContainerLifecycleMode.Project, 54 | private val beforeStart: (T) -> Unit = {}, 55 | private val afterStart: (T) -> Unit = {}, 56 | private val beforeTest: suspend (TestCase, T) -> Unit = { _, _ -> }, 57 | private val afterTest: suspend (TestCase, T) -> Unit = { _, _ -> }, 58 | private val beforeSpec: suspend (Spec, T) -> Unit = { _, _ -> }, 59 | private val afterSpec: suspend (Spec, T) -> Unit = { _, _ -> }, 60 | private val beforeShutdown: (T) -> Unit = {}, 61 | private val afterShutdown: (T) -> Unit = {}, 62 | ) : MountableExtension, 63 | AfterProjectListener, 64 | BeforeTestListener, 65 | BeforeSpecListener, 66 | AfterTestListener, 67 | AfterSpecListener { 68 | 69 | companion object { 70 | operator fun invoke(composeFile: File): DockerComposeContainerExtension> = 71 | DockerComposeContainerExtension(DockerComposeContainer(composeFile)) 72 | 73 | operator fun invoke( 74 | composeFile: File, 75 | mode: ContainerLifecycleMode = ContainerLifecycleMode.Project, 76 | ): DockerComposeContainerExtension> = 77 | DockerComposeContainerExtension(DockerComposeContainer(composeFile), mode) 78 | } 79 | 80 | private var started: Boolean = false 81 | 82 | /** 83 | * Mounts the container, starting it if necessary. The [configure] block will be invoked 84 | * every time the container is mounted, and after the container has started. 85 | */ 86 | override fun mount(configure: T.() -> Unit): T { 87 | if (!started) { 88 | beforeStart(container) 89 | container.start() 90 | started = true 91 | afterStart(container) 92 | } 93 | container.configure() 94 | return container 95 | } 96 | 97 | override suspend fun beforeTest(testCase: TestCase) { 98 | beforeTest(testCase, container) 99 | } 100 | 101 | override suspend fun afterTest(testCase: TestCase, result: TestResult) { 102 | afterTest(testCase, container) 103 | } 104 | 105 | override suspend fun beforeSpec(spec: Spec) { 106 | beforeSpec(spec, container) 107 | } 108 | 109 | override suspend fun afterSpec(spec: Spec) { 110 | afterSpec(spec, container) 111 | if (mode == ContainerLifecycleMode.Spec && started) close() 112 | } 113 | 114 | override suspend fun afterProject() { 115 | if (started) close() 116 | } 117 | 118 | private suspend fun close() { 119 | withContext(Dispatchers.IO) { 120 | beforeShutdown(container) 121 | container.stop() 122 | started = false 123 | afterShutdown(container) 124 | } 125 | } 126 | } 127 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/Extensions.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import org.testcontainers.lifecycle.Startable 4 | 5 | fun T.perTest(): StartablePerTestListener = StartablePerTestListener(this) 6 | 7 | fun T.perSpec(): StartablePerSpecListener = StartablePerSpecListener(this) 8 | 9 | fun T.perProject(): StartablePerProjectListener = StartablePerProjectListener(this) 10 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/JdbcDatabaseContainerExtension.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import com.zaxxer.hikari.HikariConfig 4 | import com.zaxxer.hikari.HikariDataSource 5 | import io.kotest.core.extensions.MountableExtension 6 | import io.kotest.core.listeners.AfterProjectListener 7 | import io.kotest.core.listeners.AfterSpecListener 8 | import io.kotest.core.listeners.AfterTestListener 9 | import io.kotest.core.listeners.BeforeSpecListener 10 | import io.kotest.core.listeners.BeforeTestListener 11 | import io.kotest.core.spec.Spec 12 | import io.kotest.core.test.TestCase 13 | import io.kotest.core.test.TestResult 14 | import kotlinx.coroutines.Dispatchers 15 | import kotlinx.coroutines.withContext 16 | import org.testcontainers.containers.JdbcDatabaseContainer 17 | import org.testcontainers.lifecycle.Startable 18 | 19 | /** 20 | * A Kotest [MountableExtension] for [JdbcDatabaseContainer]s which is started the first time they are 21 | * installed in a spec. Upon installation, this extension returns an initialized [HikariDataSource] 22 | * connected to the database. 23 | * 24 | * If no spec is executed that installs a particular container, 25 | * then that container is never started. 26 | * 27 | * @param container the specific database test container type 28 | * @param beforeSpec a beforeSpec callback 29 | * If the container is never started, this callback will not be invoked. 30 | * 31 | * @param afterSpec an afterSpec callback 32 | * If the container is never started, this callback will not be invoked. 33 | * 34 | * @param beforeTest a beforeTest callback 35 | * If the container is never started, this callback will not be invoked. 36 | * 37 | * @param afterTest a afterTest callback 38 | * If the container is never started, this callback will not be invoked. 39 | * 40 | * @param beforeStart a callback that is invoked only once, just before the container is started. 41 | * If the container is never started, this callback will not be invoked. 42 | * This callback can be useful instead of the installation callback as it will only 43 | * be executed once, regardless of how many times this container is installed. 44 | * 45 | * @param afterStart a callback that is invoked only once, just after the container is started. 46 | * If the container is never started, this callback will not be invoked. 47 | * 48 | * @param beforeShutdown a callback that is invoked only once, just before the container is stopped. 49 | * If the container is never started, this callback will not be invoked. 50 | * 51 | * @param afterShutdown a callback that is invoked only once, just after the container is stopped. 52 | * If the container is never started, this callback will not be invoked. 53 | */ 54 | class JdbcDatabaseContainerExtension( 55 | private val container: JdbcDatabaseContainer<*>, 56 | private val mode: ContainerLifecycleMode = ContainerLifecycleMode.Project, 57 | private val beforeStart: () -> Unit = {}, 58 | private val afterStart: () -> Unit = {}, 59 | private val beforeTest: suspend (TestCase, HikariDataSource) -> Unit = { _, _ -> }, 60 | private val afterTest: suspend (TestCase, HikariDataSource) -> Unit = { _, _ -> }, 61 | private val beforeSpec: suspend (Spec) -> Unit = { _ -> }, 62 | private val afterSpec: suspend (Spec, HikariDataSource) -> Unit = { _, _ -> }, 63 | private val beforeShutdown: (HikariDataSource) -> Unit = {}, 64 | private val afterShutdown: () -> Unit = { }, 65 | ) : MountableExtension, 66 | AfterProjectListener, 67 | BeforeTestListener, 68 | BeforeSpecListener, 69 | AfterTestListener, 70 | AfterSpecListener { 71 | 72 | private var dataSource: HikariDataSource? = null 73 | 74 | /** 75 | * Mounts the container, starting it if necessary. The [configure] block will be invoked 76 | * every time the container is mounted, and after the container has started. 77 | * 78 | * This will return an initialized [HikariDataSource]. 79 | * The datasource will be closed in accordance with the provided [ContainerLifecycleMode]. 80 | * 81 | * The datasource will be created with default options. If you wish to customize the datasource, 82 | * then ignore this returned value, and instead use the extension function [toDataSource] on the 83 | * container instance. 84 | */ 85 | override fun mount(configure: HikariDataSource.() -> Unit): HikariDataSource { 86 | if (!container.isRunning) { 87 | beforeStart() 88 | container.start() 89 | dataSource = container.toDataSource() 90 | afterStart() 91 | } 92 | dataSource?.configure() 93 | return dataSource ?: error("Datasource not initialized") 94 | } 95 | 96 | override suspend fun beforeTest(testCase: TestCase) { 97 | beforeTest.invoke(testCase, dataSource ?: error("Datasource not initialized")) 98 | } 99 | 100 | override suspend fun afterTest(testCase: TestCase, result: TestResult) { 101 | afterTest.invoke(testCase, dataSource ?: error("Datasource not initialized")) 102 | } 103 | 104 | override suspend fun beforeSpec(spec: Spec) { 105 | beforeSpec.invoke(spec) 106 | } 107 | 108 | override suspend fun afterSpec(spec: Spec) { 109 | afterSpec(spec, dataSource ?: error("Datasource not initialized")) 110 | if (mode == ContainerLifecycleMode.Spec && container.isRunning) close() 111 | } 112 | 113 | override suspend fun afterProject() { 114 | if (container.isRunning) close() 115 | } 116 | 117 | private suspend fun close() { 118 | withContext(Dispatchers.IO) { 119 | beforeShutdown(dataSource ?: error("Datasource not initialized")) 120 | dataSource?.close() 121 | container.stop() 122 | afterShutdown() 123 | } 124 | } 125 | } 126 | 127 | /** 128 | * Returns an initialized [HikariDataSource] connected to this [JdbcDatabaseContainer]. 129 | * 130 | * @param configure a thunk to configure the [HikariConfig] used to create the datasource. 131 | */ 132 | fun JdbcDatabaseContainer<*>.toDataSource(configure: HikariConfig.() -> Unit = {}): HikariDataSource { 133 | val config = HikariConfig() 134 | config.jdbcUrl = jdbcUrl 135 | config.username = username 136 | config.password = password 137 | config.minimumIdle = 0 138 | config.configure() 139 | return HikariDataSource(config) 140 | } 141 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/SettableDataSource.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import com.zaxxer.hikari.HikariDataSource 4 | import java.io.PrintWriter 5 | import java.sql.Connection 6 | import java.util.logging.Logger 7 | import javax.sql.DataSource 8 | 9 | class SettableDataSource(private var ds: HikariDataSource?) : DataSource { 10 | 11 | private fun getDs(): DataSource = ds ?: error("DataSource is not ready") 12 | 13 | fun setDataSource(ds: HikariDataSource?) { 14 | this.ds?.close() 15 | this.ds = ds 16 | } 17 | 18 | override fun getLogWriter(): PrintWriter { 19 | return getDs().logWriter 20 | } 21 | 22 | override fun setLogWriter(out: PrintWriter?) { 23 | getDs().logWriter = out 24 | } 25 | 26 | override fun setLoginTimeout(seconds: Int) { 27 | getDs().loginTimeout = seconds 28 | } 29 | 30 | override fun getLoginTimeout(): Int { 31 | return getDs().loginTimeout 32 | } 33 | 34 | override fun getParentLogger(): Logger { 35 | return getDs().parentLogger 36 | } 37 | 38 | override fun unwrap(iface: Class?): T { 39 | return getDs().unwrap(iface) 40 | } 41 | 42 | override fun isWrapperFor(iface: Class<*>?): Boolean { 43 | return getDs().isWrapperFor(iface) 44 | } 45 | 46 | override fun getConnection(): Connection { 47 | return getDs().connection 48 | } 49 | 50 | override fun getConnection(username: String?, password: String?): Connection { 51 | return getDs().getConnection(username, password) 52 | } 53 | 54 | } 55 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/StartablePerProjectListener.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.listeners.ProjectListener 4 | import io.kotest.core.listeners.TestListener 5 | import io.kotest.core.test.TestCase 6 | import io.kotest.core.test.TestResult 7 | import kotlinx.coroutines.Dispatchers 8 | import kotlinx.coroutines.withContext 9 | import org.testcontainers.lifecycle.Startable 10 | 11 | /** 12 | * [StartablePerProjectListener] starts the given [startable] before execution of all specs 13 | * and stops after execution of all specs. 14 | * 15 | * [startable] can any of [GenericContainer] [DockerComposeContainer] [LocalStackContainer] etc. 16 | * 17 | * This listener should be used when you want to use a single container for all tests in project. 18 | * 19 | * @see 20 | * [StartablePerTestListener] 21 | * */ 22 | class StartablePerProjectListener(private val startable: T) : TestListener, ProjectListener { 23 | 24 | private val testLifecycleAwareListener = TestLifecycleAwareListener(startable) 25 | 26 | override suspend fun beforeProject() { 27 | withContext(Dispatchers.IO) { 28 | startable.start() 29 | } 30 | } 31 | 32 | override suspend fun beforeTest(testCase: TestCase) { 33 | withContext(Dispatchers.IO) { 34 | testLifecycleAwareListener.beforeTest(testCase) 35 | } 36 | } 37 | 38 | override suspend fun afterProject() { 39 | withContext(Dispatchers.IO) { 40 | startable.stop() 41 | } 42 | } 43 | 44 | override suspend fun afterTest(testCase: TestCase, result: TestResult) { 45 | withContext(Dispatchers.IO) { 46 | testLifecycleAwareListener.afterTest(testCase, result) 47 | } 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/StartablePerSpecListener.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.listeners.TestListener 4 | import io.kotest.core.spec.Spec 5 | import io.kotest.core.test.TestCase 6 | import io.kotest.core.test.TestResult 7 | import kotlinx.coroutines.Dispatchers 8 | import kotlinx.coroutines.withContext 9 | import org.testcontainers.lifecycle.Startable 10 | import org.testcontainers.lifecycle.TestLifecycleAware 11 | 12 | 13 | /** 14 | * [StartablePerSpecListener] starts the given [startable] before execution of any test in the spec 15 | * and stops after execution of all tests. If the [startable] also inherit from [TestLifecycleAware] 16 | * then its [beforeTest] and [afterTest] method are also called by the listener. 17 | * 18 | * [startable] can any of [GenericContainer] [DockerComposeContainer] [LocalStackContainer] etc. 19 | * 20 | * This listener should be used when you want to use a single container for all tests in a single spec class. 21 | * 22 | * @see 23 | * [StartablePerTestListener] 24 | * */ 25 | class StartablePerSpecListener(private val startable: T) : TestListener { 26 | private val testLifecycleAwareListener = TestLifecycleAwareListener(startable) 27 | 28 | override suspend fun beforeSpec(spec: Spec) { 29 | withContext(Dispatchers.IO) { 30 | startable.start() 31 | } 32 | } 33 | 34 | override suspend fun beforeTest(testCase: TestCase) { 35 | withContext(Dispatchers.IO) { 36 | testLifecycleAwareListener.beforeTest(testCase) 37 | } 38 | } 39 | 40 | override suspend fun afterSpec(spec: Spec) { 41 | withContext(Dispatchers.IO) { 42 | startable.stop() 43 | } 44 | } 45 | 46 | override suspend fun afterTest(testCase: TestCase, result: TestResult) { 47 | withContext(Dispatchers.IO) { 48 | testLifecycleAwareListener.afterTest(testCase, result) 49 | } 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/StartablePerTestListener.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.listeners.TestListener 4 | import io.kotest.core.test.TestCase 5 | import io.kotest.core.test.TestResult 6 | import kotlinx.coroutines.Dispatchers 7 | import kotlinx.coroutines.withContext 8 | import org.testcontainers.lifecycle.Startable 9 | import org.testcontainers.lifecycle.TestLifecycleAware 10 | 11 | /** 12 | * [StartablePerTestListener] starts the given [startable] before execution of each test in the spec 13 | * and stops after execution of each test. If the [startable] also inherit from [TestLifecycleAware] 14 | * then its [beforeTest] and [afterTest] method are also called by the listener. 15 | * 16 | * [startable] can any of [GenericContainer] [DockerComposeContainer] [LocalStackContainer] etc. 17 | * 18 | * This should be used when you want a fresh container for each test. 19 | * 20 | * @see[StartablePerSpecListener] 21 | * */ 22 | class StartablePerTestListener(private val startable: T) : TestListener { 23 | 24 | private val testLifecycleAwareListener = TestLifecycleAwareListener(startable) 25 | 26 | override suspend fun beforeTest(testCase: TestCase) { 27 | withContext(Dispatchers.IO) { 28 | testLifecycleAwareListener.beforeTest(testCase) 29 | startable.start() 30 | } 31 | } 32 | 33 | override suspend fun afterTest(testCase: TestCase, result: TestResult) { 34 | withContext(Dispatchers.IO) { 35 | testLifecycleAwareListener.afterTest(testCase, result) 36 | startable.stop() 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/main/kotlin/io/kotest/extensions/testcontainers/TestLifecycleAwareListener.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.listeners.TestListener 4 | import io.kotest.core.test.TestCase 5 | import io.kotest.core.test.TestResult 6 | import org.testcontainers.lifecycle.Startable 7 | import org.testcontainers.lifecycle.TestDescription 8 | import org.testcontainers.lifecycle.TestLifecycleAware 9 | import java.net.URLEncoder 10 | import java.util.Optional 11 | 12 | class TestLifecycleAwareListener(startable: Startable) : TestListener { 13 | private val testLifecycleAware = startable as? TestLifecycleAware 14 | 15 | override suspend fun beforeTest(testCase: TestCase) { 16 | testLifecycleAware?.beforeTest(testCase.toTestDescription()) 17 | } 18 | 19 | override suspend fun afterTest(testCase: TestCase, result: TestResult) { 20 | testLifecycleAware?.afterTest(testCase.toTestDescription(), Optional.ofNullable(result.errorOrNull)) 21 | } 22 | } 23 | 24 | internal fun TestCase.toTestDescription() = object : TestDescription { 25 | 26 | override fun getFilesystemFriendlyName(): String { 27 | return URLEncoder.encode(testId.replace(" ", "_").replace(" -- ", "__").replace("/", "_"), "UTF-8") 28 | } 29 | 30 | override fun getTestId(): String = this@toTestDescription.descriptor.ids().joinToString("/") { it.value } 31 | } 32 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/ContainerExtensionSpecLifecycleTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import com.redis.testcontainers.RedisContainer 4 | import io.kotest.core.extensions.install 5 | import io.kotest.core.spec.style.FunSpec 6 | import io.kotest.matchers.shouldBe 7 | import org.testcontainers.containers.GenericContainer 8 | import redis.clients.jedis.JedisPool 9 | 10 | class ContainerExtensionSpecLifecycleTest : FunSpec() { 11 | init { 12 | 13 | // Using GenericContainer (which includes no out-of-the-box port mappings 14 | // to ensure the configure hook exposes ports correctly 15 | val container = install(ContainerExtension(GenericContainer("redis:7.2.5-alpine"), ContainerLifecycleMode.Spec)) { 16 | startupAttempts = 2 17 | withExposedPorts(6379) 18 | } 19 | 20 | val jedis = JedisPool(container.host, container.firstMappedPort) 21 | 22 | test("should be initialized in the spec") { 23 | jedis.resource.set("foo", "bar") 24 | jedis.resource.get("foo") shouldBe "bar" 25 | } 26 | 27 | test("this test should share the container") { 28 | jedis.resource.get("foo") shouldBe "bar" 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/DockerComposeContainerExtensionTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.extensions.install 4 | import io.kotest.core.spec.style.StringSpec 5 | import io.kotest.matchers.optional.shouldBePresent 6 | import io.kotest.matchers.string.shouldContain 7 | import org.testcontainers.containers.DockerComposeContainer 8 | import java.io.File 9 | 10 | class DockerComposeContainerExtensionTest : StringSpec() { 11 | init { 12 | 13 | val container: DockerComposeContainer = 14 | install(DockerComposeContainerExtension(File("src/test/resources/docker-compose/docker-compose.yml"))) 15 | 16 | "should setup using docker-compose" { 17 | container.getContainerByServiceName("hello_world").shouldBePresent().logs shouldContain "Hello world" 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/JdbcDatabaseContainerExtensionSpecTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.extensions.install 4 | import io.kotest.core.spec.style.FunSpec 5 | import io.kotest.matchers.shouldBe 6 | import org.testcontainers.containers.MySQLContainer 7 | 8 | class JdbcDatabaseContainerExtensionSpecTest : FunSpec() { 9 | init { 10 | 11 | val mysql = MySQLContainer("mysql:8.0.26").apply { 12 | withInitScript("init.sql") 13 | startupAttempts = 1 14 | withUrlParam("connectionTimeZone", "Z") 15 | withUrlParam("zeroDateTimeBehavior", "convertToNull") 16 | } 17 | 18 | val ds = install(JdbcDatabaseContainerExtension(mysql)) { 19 | maximumPoolSize = 8 20 | minimumIdle = 4 21 | } 22 | 23 | test("should initialize per spec") { 24 | ds.connection.use { 25 | val rs = it.createStatement().executeQuery("SELECT * FROM hashtags") 26 | rs.next() 27 | rs.getString("tag") shouldBe "startrek" 28 | 29 | it.createStatement().executeUpdate("INSERT INTO hashtags(tag) VALUES ('foo')") 30 | 31 | val rs2 = it.createStatement().executeQuery("SELECT count(*) FROM hashtags") 32 | rs2.next() 33 | rs2.getLong(1) shouldBe 2 34 | } 35 | } 36 | 37 | test("another test should have the same container") { 38 | ds.connection.use { 39 | val rs = it.createStatement().executeQuery("SELECT count(*) FROM hashtags") 40 | rs.next() 41 | rs.getLong(1) shouldBe 2 42 | } 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/JdbcMultiScriptContainerInitTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.extensions.install 4 | import io.kotest.core.spec.style.FunSpec 5 | import io.kotest.matchers.shouldBe 6 | import org.testcontainers.containers.MySQLContainer 7 | import org.testcontainers.utility.MountableFile.forClasspathResource 8 | 9 | class JdbcMultiScriptContainerInitTest : FunSpec({ 10 | 11 | val mysql = MySQLContainer("mysql:8.0.26").apply { 12 | startupAttempts = 1 13 | withUrlParam("connectionTimeZone", "Z") 14 | withUrlParam("zeroDateTimeBehavior", "convertToNull") 15 | 16 | val sqlInitDir = "/docker-entrypoint-initdb.d/" 17 | withCopyToContainer(forClasspathResource("init.sql"), sqlInitDir + "000-init.sql") 18 | withCopyToContainer(forClasspathResource("sql-changesets/001-people.sql"), sqlInitDir + "001-people.sql") 19 | withCopyToContainer(forClasspathResource("sql-changesets/002-places.sql"), sqlInitDir + "002-places.sql") 20 | } 21 | 22 | val ds = install(JdbcDatabaseContainerExtension(mysql, ContainerLifecycleMode.Spec)) { 23 | maximumPoolSize = 8 24 | minimumIdle = 4 25 | } 26 | 27 | 28 | context("with container"){ 29 | test("db should init multiple changeset files") { 30 | ds.connection.use { 31 | 32 | it.createStatement().executeUpdate("INSERT INTO hashtags(tag) VALUES ('foo')") 33 | var rsCount = it.createStatement().executeQuery("SELECT count(*) FROM hashtags") 34 | rsCount.next() 35 | rsCount.getLong(1) shouldBe 2 36 | 37 | it.createStatement().executeUpdate("INSERT INTO people(name, is_cool) VALUES ('Dima', true)") 38 | rsCount = it.createStatement().executeQuery("SELECT count(*) FROM people") 39 | rsCount.next() 40 | rsCount.getLong(1) shouldBe 3 41 | 42 | it.createStatement().executeUpdate("INSERT INTO places(city, state) VALUES ('New York', 'NY')") 43 | rsCount = it.createStatement().executeQuery("SELECT count(*) FROM places") 44 | rsCount.next() 45 | rsCount.getLong(1) shouldBe 3 46 | } 47 | } 48 | } 49 | 50 | }) 51 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/SharedJdbcDatabaseContainerExtensionTest.kt: -------------------------------------------------------------------------------- 1 | @file:Suppress("SqlResolve") 2 | 3 | package io.kotest.extensions.testcontainers 4 | 5 | import io.kotest.core.extensions.install 6 | import io.kotest.core.spec.style.FunSpec 7 | import io.kotest.matchers.shouldBe 8 | import org.testcontainers.containers.MySQLContainer 9 | 10 | private val mysql = MySQLContainer("mysql:8.0.26").apply { 11 | withInitScript("init.sql") 12 | startupAttempts = 1 13 | withUrlParam("connectionTimeZone", "Z") 14 | withUrlParam("zeroDateTimeBehavior", "convertToNull") 15 | } 16 | 17 | private val ext = JdbcDatabaseContainerExtension(mysql) 18 | 19 | class SharedJdbcTestContainerExtensionSpecTest1 : FunSpec() { 20 | init { 21 | 22 | val ds = install(ext) { 23 | maximumPoolSize = 8 24 | minimumIdle = 4 25 | } 26 | 27 | test("should initialize once per module") { 28 | ds.connection.use { 29 | val rs = it.createStatement().executeQuery("SELECT * FROM hashtags") 30 | rs.next() 31 | rs.getString("tag") shouldBe "startrek" 32 | 33 | it.createStatement().executeUpdate("INSERT INTO hashtags(tag) VALUES ('foo')") 34 | 35 | val rs2 = it.createStatement().executeQuery("SELECT count(*) FROM hashtags") 36 | rs2.next() 37 | rs2.getLong(1) shouldBe 2 38 | } 39 | } 40 | 41 | test("another test should use the same container") { 42 | ds.connection.use { 43 | val rs = it.createStatement().executeQuery("SELECT count(*) FROM hashtags") 44 | rs.next() 45 | rs.getLong(1) shouldBe 2 46 | } 47 | } 48 | } 49 | } 50 | 51 | class SharedJdbcTestContainerExtensionSpecTest2 : FunSpec() { 52 | init { 53 | 54 | val ds = install(ext) 55 | 56 | test("another spec should use the same container") { 57 | ds.connection.use { 58 | val rs = it.createStatement().executeQuery("SELECT count(*) FROM hashtags") 59 | rs.next() 60 | rs.getLong(1) shouldBe 2 61 | } 62 | } 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/SharedTestContainerExtensionTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.extensions.install 4 | import io.kotest.core.spec.style.FunSpec 5 | import io.kotest.matchers.shouldBe 6 | import org.testcontainers.containers.GenericContainer 7 | import redis.clients.jedis.JedisPool 8 | 9 | private val container = GenericContainer("redis:5.0.3-alpine").apply { 10 | startupAttempts = 2 11 | withExposedPorts(6379) 12 | } 13 | 14 | private val ext = ContainerExtension(container) 15 | 16 | class SharedTestContainerExtensionTest1 : FunSpec() { 17 | init { 18 | 19 | val installed = install(ext) 20 | val jedis = JedisPool(installed.host, installed.firstMappedPort) 21 | 22 | 23 | test("should be initialized in the spec") { 24 | jedis.resource.set("foo", "bar") 25 | jedis.resource.get("foo") shouldBe "bar" 26 | } 27 | 28 | test("this test should share the container") { 29 | jedis.resource.get("foo") shouldBe "bar" 30 | } 31 | } 32 | } 33 | 34 | class SharedTestContainerExtensionTest2 : FunSpec() { 35 | init { 36 | 37 | val installed = install(ext) 38 | val jedis = JedisPool(installed.host, installed.firstMappedPort) 39 | 40 | test("this spec should share the container") { 41 | jedis.resource.get("foo") shouldBe "bar" 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/StartableTestLifecycleAware.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | 4 | import org.testcontainers.lifecycle.TestDescription 5 | import org.testcontainers.lifecycle.TestLifecycleAware 6 | import java.util.* 7 | 8 | internal class StartableTestLifecycleAware : TestStartable(), TestLifecycleAware { 9 | val testDescriptions = mutableListOf() 10 | 11 | override fun beforeTest(description: TestDescription?) { 12 | testDescriptions.add(description) 13 | } 14 | 15 | override fun afterTest(description: TestDescription?, throwable: Optional?) { 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/StartableTestLifecycleAwareTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.spec.style.StringSpec 4 | import io.kotest.matchers.collections.shouldHaveSize 5 | 6 | class StartableTestLifecycleAwareTest : StringSpec({ 7 | 8 | val startableTestLifecycleAwareForPerTest = StartableTestLifecycleAware() 9 | val startableTestLifecycleAwareForPerSpec = StartableTestLifecycleAware() 10 | 11 | listeners(startableTestLifecycleAwareForPerTest.perTest(), startableTestLifecycleAwareForPerSpec.perSpec()) 12 | 13 | "beforeTestCount for first test should be one" { 14 | startableTestLifecycleAwareForPerTest.testDescriptions shouldHaveSize 1 15 | startableTestLifecycleAwareForPerSpec.testDescriptions shouldHaveSize 1 16 | } 17 | 18 | "beforeTestCount for second test should be two" { 19 | startableTestLifecycleAwareForPerTest.testDescriptions shouldHaveSize 2 20 | startableTestLifecycleAwareForPerSpec.testDescriptions shouldHaveSize 2 21 | } 22 | }) 23 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/TestContainerIntegrationPerSpec.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.spec.style.StringSpec 4 | import io.kotest.matchers.shouldBe 5 | 6 | class TestContainerIntegrationPerSpec : StringSpec({ 7 | 8 | val testStartable = TestStartable() 9 | listener(testStartable.perSpec()) 10 | 11 | "start count for first test should be one" { 12 | testStartable.startCount shouldBe 1 13 | } 14 | 15 | "start count for second test should also be one" { 16 | testStartable.startCount shouldBe 1 17 | } 18 | }) 19 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/TestContainerIntegrationPerTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.spec.style.StringSpec 4 | import io.kotest.matchers.shouldBe 5 | 6 | class TestContainerIntegrationPerTest : StringSpec({ 7 | 8 | val testStartable = TestStartable() 9 | listener(testStartable.perTest()) 10 | 11 | "start count for first test should be one" { 12 | testStartable.startCount shouldBe 1 13 | } 14 | 15 | "start count for second test should be two" { 16 | testStartable.startCount shouldBe 2 17 | } 18 | }) 19 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/TestLifecycleAwareListenerTest.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import io.kotest.core.spec.style.StringSpec 4 | import io.kotest.matchers.shouldBe 5 | 6 | class TestLifecycleAwareListenerTest : StringSpec({ 7 | val startableTestLifecycleAware = StartableTestLifecycleAware() 8 | val startable = TestStartable() 9 | val testLifecycleAwareListener = TestLifecycleAwareListener(startableTestLifecycleAware) 10 | val anotherTestLifecycleAwareListener = TestLifecycleAwareListener(startable) 11 | 12 | listeners(testLifecycleAwareListener, anotherTestLifecycleAwareListener) 13 | 14 | "it should not break for listener having startable which is not of type testLifecycleAware" { 15 | startable.startCount shouldBe 0 16 | } 17 | 18 | "test id in test description should be combination of test name and spec name" { 19 | val testDescription = startableTestLifecycleAware.testDescriptions[1] 20 | testDescription?.testId shouldBe "io.kotest.extensions.testcontainers.TestLifecycleAwareListenerTest/test id in test description should be combination of test name and spec name" 21 | } 22 | 23 | "fileSystemFriendlyName .. in /// test description should be encoded test name" { 24 | val testDescription = startableTestLifecycleAware.testDescriptions[2] 25 | val encodedTestName = "io.kotest.extensions.testcontainers.TestLifecycleAwareListenerTest_fileSystemFriendlyName_.._in_____test_description_should_be_encoded_test_name" 26 | 27 | testDescription?.filesystemFriendlyName shouldBe encodedTestName 28 | } 29 | }) 30 | -------------------------------------------------------------------------------- /src/test/kotlin/io/kotest/extensions/testcontainers/TestStartable.kt: -------------------------------------------------------------------------------- 1 | package io.kotest.extensions.testcontainers 2 | 3 | import org.testcontainers.lifecycle.Startable 4 | 5 | internal open class TestStartable : Startable { 6 | var startCount = 0 7 | override fun start() { 8 | startCount++ 9 | } 10 | override fun stop() { 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/test/resources/docker-compose/docker-compose.yml: -------------------------------------------------------------------------------- 1 | version: '2' 2 | services: 3 | hello_world: 4 | image: ubuntu 5 | command: [/bin/echo, 'Hello world'] 6 | -------------------------------------------------------------------------------- /src/test/resources/init.sql: -------------------------------------------------------------------------------- 1 | create table hashtags 2 | ( 3 | id bigint auto_increment primary key, 4 | tag varchar(100) not null 5 | ); 6 | 7 | 8 | insert into hashtags (tag) 9 | values ('startrek'); 10 | -------------------------------------------------------------------------------- /src/test/resources/sql-changesets/001-people.sql: -------------------------------------------------------------------------------- 1 | create table people ( 2 | id serial primary key, 3 | name varchar(25) not null, 4 | is_cool boolean 5 | ); 6 | -- THIS COMMENT SHOULD BE IGNORED 7 | INSERT INTO people (name, is_cool) 8 | VALUES 9 | ('Scott', true), 10 | ('Sam', false); 11 | -------------------------------------------------------------------------------- /src/test/resources/sql-changesets/002-places.sql: -------------------------------------------------------------------------------- 1 | create table places ( 2 | id serial primary key, 3 | city varchar(25) not null, 4 | state varchar(2) not null 5 | ); 6 | 7 | INSERT INTO places (city, state) 8 | VALUES 9 | ('Chicago', 'IL'), 10 | ('Reno', 'NV'); 11 | --------------------------------------------------------------------------------