CODEWITHSUNDEEP
unit-testinggoworking-directory
Jesse Brands
Jesse Brands

Reputation: 2887

Golang: tests and working directory

I'm writing some unit tests for my application in Go. The tests fail however because it cannot find the configuration files. Normally the binary looks for the configuration files in the working directory under the path conf/*.conf.

I figured that browsing to the directory that has conf/ and running go test in it would solve it, but it still reports that the file system cannot find the path specified.

How can I tell go test to use a certain directory as the working directory so that the tests may actually be executed?

Upvotes: 105

Views: 80263

Answers (15)

Kevin Chien
Kevin Chien

Reputation: 1

One other approach is captured by this JetBrains article. It's also the same as the approach proposed by this comment.

Summarized:

In your project root, create a new directory testing_init and file testing_init.go with the following content:

package testing_init

import (
  "os"
  "path"
  "runtime"
)

func init() {
  _, filename, _, _ := runtime.Caller(0)
  dir := path.Join(path.Dir(filename), "..")
  err := os.Chdir(dir)
  if err != nil {
    panic(err)
  }
}

After that, just import the package into any of the test files:

package main_test

import (
  _ "project/testing_init"
)

Now you can specify paths from the project root.

If you need testing_init.go to live nested deeper in your project, just add the appropriate amount of ../ to the dir := path.Join(path.Dir(filename), "..") line, to allow you to reach the project root.

You can import this package from anywhere and it will always work, because runtime.Caller(0) is being called by testing_init.go, and it will always return the filepath of testing_init.go, allowing you to deterministically set the os directory to the project root based on where it is relative to testing_init.go.

Upvotes: 0

Sergey Ponomarev
Sergey Ponomarev

Reputation: 3201

Here is function to find a root project directory that contains .git folder:

import (
    "os"
    "path/filepath"
)

func FindProjectDir() string {
    // Test can be started from command line in project folder or in IDE
    // Try to detect a correct path to a project directory

    // Find a project dir that contains .git
    curDir, _ := os.Getwd()
    projectDir := curDir
    for {
        _, err := os.Stat(projectDir + "/.git")
        if err == nil {
            return projectDir
        }
        projectDir = filepath.Dir(projectDir)
        if projectDir == "/" { // reached root
            return ""
        }
    }
}

You can adapt it and append the file name that you are looking for. Still I think this answer is better https://stackoverflow.com/a/71488632/1049542 But sometime you need also to execute some shell script in the project root folder so you need to know the parent folder.

Upvotes: 0

VinGarcia
VinGarcia

Reputation: 1205

I currently use a neat solution for this problem, instead of opening the file directly by calling os.Open(), I use the embed package in a smart way:

First I create a global variable in my root package called:

//go:embed config/* otherdirectories/*
var RootFS embed.FS

Then I just open the files inside my tests by using this global variable, e.g.:

func TestOpenConfig(t *testing.T) {
    configFile, err := rootpkg.RootFS.ReadFile("config/env")
    if err != nil {
        t.Fatalf("unable to open config/env file: %s", err)
    }

    if string(configFile) != "FOO=bar\n" {
        t.Fatalf("config file contents differ from expected: %s", string(configFile))
    }
}

This is a neat trick because now you can always work with relative paths from your root package, which is what I used to do in other programming languages.

Of course, this has the restriction that you will need to import your root package, which depending on your package layout might not be ideal because of cyclic imports. If this is your case you might just create a embed.go file inside the config directory itself.

One other drawback is that you are embedding test files in your binary, this is probably ok if your test files are not very big, like megabytes big, so I don't really mind this issue.

I also created a repository for illustrating this solution:

https://github.com/VinGarcia/golang-reading-files-from-tests

Upvotes: 4

lzap
lzap

Reputation: 17173

Go 1.20 is getting new -C arguments for "go subcommands" so this should help:

go test -C directory/ ...

Upvotes: 3

Alex Kosh
Alex Kosh

Reputation: 2554

It's a common practice in Go to place test fixtures in same package inside testdata folder.

Some examples from standard library:

Also, there is a post from Dave Cheney, where he suggests following code:

f, err := os.Open("testdata/somefixture.json")

Upvotes: 0

Seven Liu
Seven Liu

Reputation: 121

To add init function into *_test.go under your test package. Test package will run this function before test function start.

func init() {
    _, filename, _, _ := runtime.Caller(0)
    // The ".." may change depending on you folder structure
    dir := path.Join(path.Dir(filename), "..")
    err := os.Chdir(dir)
    if err != nil {
        panic(err)
    }  
}

Upvotes: 12

Gustavo Falco
Gustavo Falco

Reputation: 130

I know this is an old question but I had the same problem trying to use migrations for the database on my tests, and maybe this solution helps someone.

Since there is no native way of getting the project directory, you could identify some file or directory that you know it's only in the root of the project (in my case, it was the relative directory database/migrations). Once you have this unique relative directory, you could have a function like the following to obtain the project root directory. It just gets the current working directory (assuming it's inside the project's directory) and starts to navigate all the way up until it finds a dir that has the relative directory you know it's on the root of the project:

func FindMyRootDir() string {
    workingDirectory, err := os.Getwd()

    if err != nil {
        panic(err)
    }

    lastDir := workingDirectory
    myUniqueRelativePath := "database/migrations"

    for {
        currentPath := fmt.Sprintf("%s/%s", lastDir, myUniqueRelativePath)

        fi, err := os.Stat(currentPath)

        if err == nil {
            switch mode := fi.Mode(); {
            case mode.IsDir():
                return currentPath
            }
        }

        newDir := filepath.Dir(lastDir)

        // Ooops, we couldn't find the root dir. Check that your "myUniqueRelativePath" really exists

        if newDir == "/" || newDir == lastDir {
            return ""
        }

        lastDir = newDir
    }
}

Of course it's not the most beautiful solution, but it works.

Upvotes: 2

N8Theo
N8Theo

Reputation: 706

You may be able to use the Caller to get the path to the current test source file, like this:

package sample

import (
    "testing"
    "runtime"
    "fmt"
)

func TestGetFilename(t *testing.T) {
    _, filename, _, _ := runtime.Caller(0)
    t.Logf("Current test filename: %s", filename)
}

Upvotes: 67

HClx
HClx

Reputation: 491

I've had a similar problem and found the solution on this blog

Basically you can change the folder that the test is running using a similar function:

package main

import (
    "os"
    "path"
    "runtime"
)

func MakeFunctionRunOnRootFolder() {
    _, filename, _, _ := runtime.Caller(0)
    // The ".." may change depending on you folder structure
    dir := path.Join(path.Dir(filename), "..")
    err := os.Chdir(dir)
    if err != nil {
        panic(err)
    }
}

Upvotes: 3

Tecker.Yu
Tecker.Yu

Reputation: 191

No matter where the work directory is. It must be under your project Dir. So my solution is

wd, _ := os.Getwd()
for !strings.HasSuffix(wd, "<yourProjectDirName>") {
    wd = filepath.Dir(wd)
}

raw, err := ioutil.ReadFile(fmt.Sprintf("%s/src/conf/conf.dev.json", wd))

Your path should always start from your project Dir. Every time you read the file in a package and accessed by main.go or your another package unit test. It will always work.

Upvotes: 18

kristianp
kristianp

Reputation: 5915

I would use an Environment Variable for the location of your application. It seems to be the best way when running go tools, as test programs can be run from a temporary location.

// get home dir of app, use MYAPPHOME env var if present, else executable dir.
func exeDir() string {
    dir, exists := os.LookupEnv("MYAPPHOME")
    if exists {
        return dir
    } else {
        ex, err := os.Executable()
        if err != nil {
            panic(err)
        }
        exPath := path.Dir(ex)
        return exPath
    }
}

Upvotes: -1

amazingfly
amazingfly

Reputation: 119

You can use the os package.

You would want to do something like this

    func TestMyFunction(t *testing.T) {
        os.Chdir("./path")

        //TEST FUNCTION

        os.Chdir("..")
    }

There are several possibilities in the os package.

Upvotes: 11

Joe
Joe

Reputation: 1432

As a workaround, I compiled the test and execute the test from the current directory.

go test -c && ./<mypackage>.test

Or, if you want a generic command that you can use, you can rename the test file with -o option.

go test -c -o xyz.test && ./xyz.test

Upvotes: 23

OneOfOne
OneOfOne

Reputation: 99391

While not really convenient, you can always pass it as a command line variable, for example :

package blah_test

import (
    "flag"
    "fmt"
    "os"
    "testing"
)

var (
    cwd_arg = flag.String("cwd", "", "set cwd")
)

func init() {
    flag.Parse()
    if *cwd_arg != "" {
        if err := os.Chdir(*cwd_arg); err != nil {
            fmt.Println("Chdir error:", err)
        }
    }
}

func TestBlah(t *testing.T) {
    t.Errorf("cwd: %+q", *cwd_arg)
}

Then run it like :

┌─ oneofone@Oa [/tmp]                                                                                             
└──➜ go test . -cwd="$PWD"
--- FAIL: TestBlah (0.00 seconds)
        blah_test.go:16: cwd: "/tmp"

Upvotes: 13

Evan
Evan

Reputation: 6555

I do not believe this is possible. I have not been able to find documentation stating this explicitly, but I believe go test always uses the package directory (containing the go source files) as the working directory.

Upvotes: 33

Related Questions