How do I know I'm running within "go test"

When I run "go test", I want to use a different configuration file. How do I know within my code if I'm running within a test context or a normal context? Is there some sort of environment variable to check?

The testing package modifies the global environment when loaded: it registers a lot of command-line flags. So, we can check if these flags are registered:

func init() {
	if flag.Lookup("test.v") == nil {
		fmt.Println("normal run")
	} else {
		fmt.Println("run under go test")
	}
}

Since the flag.Lookup("test.v") approach does not work for me, I'd like to share my own solution:

strings.HasSuffix(os.Args[0], ".test")

Or

strings.Contains(os.Args[0], "/_test/")

Both seem to work.

The flag.Lookup("test.v") == nil method seems to work but I would recommend using TestMain, which is specifically designed to allow specific setup and teardown for tests. If you include this method in the package you want to test, it will be called before your individual tests and so you can set a global flag or perform whatever test-specific configuration you want to do before calling m.Run() as follows

func TestMain(m *testing.M) {
    // test context initialization here
    os.Exit(m.Run())
}

PS: this is actually what @calvin-sugianto suggested, except Gin has nothing to do with it

One possibility would be to use build constraints. If you run go test as:

go test -tags testing pkgname

Then you can use that tag to select which files will be included in a standard build of your package, and which will be used for testing.

If you put your standard configuration in a file of its own, then adding a line to the top like the following will ensure that it is not used for testing:

// +build !testing

You can then include the testing configuration in one of the *_test.go files, or in some other file that requires that the testing tag be set.

Code examples would help. But from your question it sounds like you've hardcoded a path to a config file somewhere when you probably wanted to pass it in instead.

Change the function you are testing to take a parameter defining the config file and then in your test code pass a different path in than you use in the non test code. It's bad practice for your code to have a different path when testing vs production.

> How do I know within my code if I'm running within a test context or a normal context?

Go 1.22 (Q3 2023) or Go 1.23 (Q1 2024) could provide this feature, considering the proposal "# 5600 testing: add func Testing() bool" has been accepted, and is currently implemented.
See CL 475496:

> ## testing: add Testing function
>
> The Testing function reports whether the program is a test created by "go test".

With src/testing/testing.go

// testBinary is set by cmd/go to "1" if this is a binary built by "go test".
// The value is set to "1" by a -X option to cmd/link. We assume that
// because this is possible, the compiler will not optimize testBinary
// into a constant on the basis that it is an unexported package-scope
// variable that is never changed. If the compiler ever starts implementing
// such an optimization, we will need some technique to mark this variable
// as "changed by a cmd/link -X option".
var testBinary = "0"

// Testing reports whether the current code is being run in a test.
// This will report true in programs created by "go test",
// false in programs created by "go build".
func Testing() bool {
	return testBinary == "1"
}

Example:

package main
import (
	"fmt"
	"testing"
)
func main() {
	fmt.Println(testing.Testing())
}

func TestTesting(t *testing.T) {
	if !testing.Testing() {
		t.Errorf("testing.Testing() == %t, want %t", testing.Testing(), true)
	}
}

Use case example:

> With testing.Testing() I can easily guard non-unit-tests code with:
>
>go
>// file/that/should/not/be/used/from/testing.go
>
>func prodEnvironmentData() *Environment {
> if testing.Testing() {
> log.Fatal("Using production data in unit tests")
> }
> ....
>}
>

I am new to golang and flag.Lookup("test.v") did not work for me, So i have found way to identify if context is testing or normal by setting ENV variable in init().

If you have test file for example abc.text.go, set env variable "GO_ENV" to testing in init().

func init() {
	os.Setenv("GO_ENV", "testing")
}

And where ever you want to know the context use os.Getenv("GO_ENV")
abc.go

if os.Getenv("GO_ENV") == "testing" {

} else {

}

The flag.Lookup("test.v") solution does not work for me either (go 1.13), and I have lots of services to maintain and it is not feasible to use the func TestMain(m *testing.M) solution in every service. As all the services share a common library, I've come up with the following solution:

func isInTests() bool {
    for _, arg := range os.Args {
        if strings.HasPrefix(arg, "-test.v=") {
            return true
        }
    }
    return false
}

This is similar to the flag.Lookup("test.v") solution because we check if -test.v is present.

EDIT: updated the code based on @mh-cbon comment

Similar to Pram's answer I might set an environment variable when you run the tests.

Makefile

test:
 ENV=testing go test ./...

main.go

  env := os.Getenv("ENV")

If your trying to detect if the file is being run through "go run" vs an executable, this function checks if the directory contains "/Temp/go-build" (also checks for \ for windows support)

if strings.Index(os.Args[0], "/Temp/go-build") != -1 || strings.Index(os.Args[0], "\\Temp\\go-build") != -1 {
    // ran with go run
} else {
    // ran as executable file
}

A different approach will be using a seperate init() func in test file per package.

Since *_test.go runs only during 'go test' we could

feature/feature_setup_test.go

package feature

fun init() {  
       fmt.Println("Code For Test initialization")
}

This init() func from test is called only during testing; Unlike an init() func from feature.go which will with every import/run.

And one more thing when we do testing, init() in test will get executed only after non-test init() function.

So you can override the a feature.go -> init() with feature_test.go -> init().

Sample code available in gist.

Check if _test.go exist in stack.

package utils

import (
	"runtime/debug"
	"strings"
)

func IsInTest() bool {
	stacks := strings.Split(string(debug.Stack()), "\n")
	for _, line := range stacks {
		if strings.HasPrefix(line, "\t") {
			path := strings.Split(strings.TrimSpace(line), ":")[0]
			if strings.HasSuffix(path, "_test.go") {
				return true
			}
		}
	}
	return false
}

More robust solution that Garrett's one is:

 func init() {
    if v := flag.Lookup("test.v"); v == nil || v.Value.String() != "true" {
        fmt.Println("normal run")
    } else {
        fmt.Println("run under go test")
    }
 }