How to read a text file from resources in Kotlin?

Question

I want to write a Spek test in Kotlin.
How to read an HTML file from the src/test/resources folder?

class MySpec : Spek(
    {
        describe("blah blah") {
            given("blah blah") {
                var fileContent: String = ""
                beforeEachTest {
                    // How to read the file.html in src/test/resources/html/
                    fileContent = ...
                }
                it("should blah blah") {
                    ...
                }
            }
        }
    }
)

Answer 1

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

Answer 2

No idea why this is so hard, but the simplest way I've found (without having to refer to a particular class) is:

fun getResourceAsText(path: String): String? =
    object {}.javaClass.getResource(path)?.readText()

It returns null if no resource with this name is found (as documented).

And then passing in an absolute URL, e.g.

val html = getResourceAsText("/www/index.html")!!

Answer 3

another slightly different solution:

@Test
fun basicTest() {
    "/html/file.html".asResource {
        // test on `it` here...
        println(it)
    }

}

fun String.asResource(work: (String) -> Unit) {
    val content = this.javaClass::class.java.getResource(this).readText()
    work(content)
}

Answer 4

A slightly different solution:

class MySpec : Spek({
    describe("blah blah") {
        given("blah blah") {

            var fileContent = ""

            beforeEachTest {
                html = this.javaClass.getResource("/html/file.html").readText()
            }

            it("should blah blah") {
                ...
            }
        }
    }
})

Answer 5

Kotlin + Spring way:

@Autowired
private lateinit var resourceLoader: ResourceLoader

fun load() {
    val html = resourceLoader.getResource("classpath:html/file.html").file
        .readText(charset = Charsets.UTF_8)
}

Answer 6

Using Google Guava library Resources class:

import com.google.common.io.Resources;

val fileContent: String = Resources.getResource("/html/file.html").readText()

Answer 7

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

Answer 8

private fun loadResource(file: String) = {}::class.java.getResource(file).readText()

Answer 9

This is the way that I prefer to do it:

fun getResourceText(path: String): String {
    return File(ClassLoader.getSystemResource(path).file).readText()
}

Answer 10

this top-level kotlin function will do the job in any case

fun loadResource(path: String): URL {
    return Thread.currentThread().contextClassLoader.getResource(path)
}

or if you want a more robust function

fun loadResource(path: String): URL {
    val resource = Thread.currentThread().contextClassLoader.getResource(path)
    requireNotNull(resource) { "Resource $path not found" }
    return resource
}

Answer 11

FYI: In all the above cases. getResource() is unsafe way of using nullable.

Haven't tried locally but I prefer this way:

fun readFile(resourcePath: String) = String::class.java.getResource(resourcePath)?.readText() ?: "<handle default. or handle custom exception>"

Or even as custom datatype function

private fun String.asResource() = this::class.java.getResource(resourcePath)?.readText() ?: "<handle default. or handle custom exception>"

and then you can call directly on path like:

// For suppose
val path = "/src/test/resources"
val content = path.asResource()

Answer 12

I prefer reading resources in this way:

object {}.javaClass.getResourceAsStream("/html/file.html")?.use { it.reader(Charsets.UTF_8).readText() }

Explenation:

• getResourceAsStream instead getResource. The resource on classpath can be basically anywhere. e.g. packed inside another .jar file.
  In these situations accessing resource via URL class returned from getResource method will fail. But accessing via method getResourceAsStream works in every situation.
• object {} - This is not nice syntax, but it is not dependent on name of your class MyClass and works even in static (compenion object) block.
• use to close stream - in most cases it is not necessary, but there can be some special classloaders, which may need it.
• reader(Charsets.UTF_8) - UTF_8 is default encoding, but I prefer to be explicit. If you will encode your resource files in other encoding e.g. ISO-8859-2 you will not overlook it.

Answer 13

Another variation that handles null resource in place:

val content = object {}.javaClass
    .getResource("/html/file.html")
    ?.let(URL::readText)
    ?: error("Cannot open/find the file")
//  ?: "default text" // Instead of error()

Answer 14

fun Any.resourceString(path: String): String =
    this.javaClass.getResource(path)?.readText() ?: error("Can't load resource at $path")

Call to this extension function looks relative to the class where call is made.

Answer 15

You might find the File class useful:

import java.io.File

fun main(args: Array<String>) {
  val content = File("src/main/resources/input.txt").readText()
  print(content)
}