How to Read Files from src/test/resources in Kotlin

By the end of this page, you will understand how Kotlin tests access files in src/test/resources, how to read those files safely as text, and which resource-loading approach to use in real test code. You will also see practical examples for Spek and general Kotlin test setups.

In Kotlin and Java projects, files inside src/test/resources are not usually accessed by hardcoded filesystem paths during tests. Instead, they are placed on the test classpath by the build tool.

That means the usual way to read them is:

• locate the resource by its classpath path, such as html/file.html
• open it as a stream or URL
• convert it to a String

This matters because classpath-based loading is more reliable than using direct paths like:

File("src/test/resources/html/file.html")

A direct path may work on your machine, but it can fail when:

• the working directory changes
• tests run in CI
• the project is packaged differently
• the code runs from a JAR or another environment

Using the class loader is the standard approach because it works with how test resources are actually provided to your code.

In Kotlin tests, the most common pattern is:

val text = javaClass.getResource("/html/file.html")!!.readText()

or:

val text = javaClass.classLoader
    .getResourceAsStream("html/file.html")!!
    .bufferedReader()
    .use { it.readText() }

Both approaches read a file from the classpath. The important idea is that becomes the root of the resource path during test execution.

Think of src/test/resources as a special storage shelf that your test runner packs into a toolbox before your tests start.

You do not usually walk to the original shelf location by file path. Instead, you ask the toolbox:

• “Do you have html/file.html?”
• If yes, give me its contents.

So:

• src/test/resources = the source shelf in your project
• classpath = the packed toolbox available at runtime
• getResource(...) = asking the toolbox for a named item

This is why resource loading uses names like html/file.html instead of full source-folder paths.

The most common way to read a text resource in Kotlin is with getResource or getResourceAsStream.

Option 1: Using getResource(...).readText()

val fileContent = object {}.javaClass.getResource("/html/file.html")!!.readText()

What this does

• getResource("/html/file.html") looks for the file on the classpath
• the leading / means the path starts from the classpath root
• !! means you expect the file to exist; if not, the test fails immediately
• readText() reads the file contents into a String

Option 2: Using getResourceAsStream(...)

val fileContent = object {}.javaClass.classLoader
    .getResourceAsStream("html/file.html")!!
    .bufferedReader()
    .use { it.readText() }

Why use this version?

This is a very common Java/Kotlin pattern and works well when you want explicit stream handling.

Consider this example:

val text = MySpec::class.java
    .getResource("/html/file.html")!!
    .readText()

Here is what happens step by step:

1. MySpec::class.java

   • Gets the Java Class object for MySpec.

2. .getResource("/html/file.html")

   • Asks the class loader to find a resource named html/file.html from the classpath root.
   • Because the file is in src/test/resources/html/file.html, it should be found during test execution.

3. !!

   • If the resource is not found, getResource(...) returns null.
   • !! turns that into an immediate failure with a NullPointerException.
   • In tests, this can be acceptable because a missing test resource should fail fast.

Reading test resources is common in many kinds of Kotlin projects.

Common use cases

• HTML testing
  • load sample HTML pages and verify parsing or rendering logic
• JSON API testing
  • store sample request/response payloads in src/test/resources
• XML processing
  • test XML parsing with realistic fixture files
• Template testing
  • compare generated output with expected text files
• Data-driven tests
  • keep test input files separate from code for readability

Example: JSON fixture

val json = MySpec::class.java.getResource("/responses/user.json")!!.readText()

Example: expected HTML output

val expectedHtml = MySpec::class.java.getResource("/html/expected.html")!!.readText()

In real projects, developers usually wrap resource loading in a small utility so tests stay clean.

Common patterns

1. Test fixture helper

object TestResources {
    fun readText(path: String): String {
        return TestResources::class.java.getResource(path)?.readText()
            ?: error("Missing resource: $path")
    }
}

Usage:

val html = TestResources.readText("/html/file.html")

2. Fail-fast validation

Tests often use error(...) or requireNotNull(...) so a missing fixture gives a clear message.

val url = requireNotNull(MySpec::class.java.getResource("/html/file.html")) {
    "Resource not found: /html/file.html"
}
val html = url.readText()

3. Keep fixtures realistic

Teams usually store:

• API payload samples
• rendered HTML snapshots

Here are common beginner mistakes when reading test resources in Kotlin.

1. Using the source folder path directly

Broken approach:

val text = java.io.File("src/test/resources/html/file.html").readText()

Why this is risky

• depends on the current working directory
• may fail in CI or different build setups
• does not use the classpath

Better

val text = MySpec::class.java.getResource("/html/file.html")!!.readText()

2. Forgetting the correct resource path

Broken approach:

val text = MySpec::class.java.getResource("file.html")!!.readText()

If your file is actually in html/file.html, this will not find it.

Better

val text = MySpec::class.java.getResource("/html/file.html")!!.readText()

3. Confusing getResource and

getResource vs getResourceAsStream

Quick reference

Read a test resource as text

val text = MySpec::class.java.getResource("/html/file.html")!!.readText()

Read with class loader

val text = MySpec::class.java.classLoader
    .getResourceAsStream("html/file.html")!!
    .bufferedReader()
    .use { it.readText() }

Safe version with custom error

val text = MySpec::class.java.getResource("/html/file.html")?.readText()
    ?: error("Resource not found: /html/file.html")

Rules to remember

• src/test/resources becomes part of the test classpath
• use classpath paths like html/file.html
• with Class.getResource(...), "/" means classpath root
• prefer resource loading over direct filesystem paths in tests
• use use {} when working with streams

Common paths

If file is here:

How do I read a file from src/test/resources in Kotlin?

Use classpath resource loading, for example:

val text = MySpec::class.java.getResource("/html/file.html")!!.readText()

Why should I avoid File("src/test/resources/...") in tests?

Because it depends on the current working directory and is less reliable across environments.

What path should I use for a file in src/test/resources/html/file.html?

Usually either:

"/html/file.html"

with getResource(...), or:

"html/file.html"

with getResourceAsStream(...).

What happens if the resource does not exist?

getResource(...) or getResourceAsStream(...) returns null. You should handle that with requireNotNull, , or in tests.

• Classpath — test resources are loaded from the classpath at runtime.
• InputStream — useful when reading resource files as streams.
• File I/O in Kotlin — related for reading local files, but different from classpath resources.
• Null safety in Kotlin — important because resource lookups can return null.
• Unit testing in Kotlin — resource files are commonly used as test fixtures.
• Spek testing framework — relevant because the original example uses Spek hooks like beforeEachTest.
• Reusable test fixtures — helps organize sample files such as HTML, JSON, and XML.
• Kotlin extension functions — often used to create helper functions for cleaner test code.