integrationtest

func NewBinHandler ¶ added in v1.4.13

func NewBinHandler(opts ...BinOpt) *BinHandler

func BinOptBase ¶ added in v1.4.13

func BinOptBase(base string) BinOpt

BinOptBase sets execution base path BinHandler. BinOptBase should be usually the first option when passing options to NewIntegrationTestRunner.

func BinOptBuildArgs ¶ added in v1.4.13

func BinOptBuildArgs(args ...string) BinOpt

BinOptBuildArgs adds args to build arguments for test binary.

func BinOptBuildEnv ¶ added in v1.4.13

func BinOptBuildEnv(env ...string) BinOpt

BinOptBuildEnv adds env to test binary's build env.

func BinOptCoverDir ¶ added in v1.4.13

func BinOptCoverDir(coverDir string) BinOpt

BinOptCoverDir sets coverage directory for test binary.

func BinOptOutput ¶ added in v1.4.13

func BinOptOutput(output string) BinOpt

BinOptOutput sets output for compilation target.

func BinOptRunArgs ¶ added in v1.4.13

func BinOptRunArgs(args ...string) BinOpt

BinOptRunArgs adds args to run arguments for test binary.

func BinOptRunEnv ¶ added in v1.4.13

func BinOptRunEnv(env ...string) BinOpt

BinOptRunEnv adds env to test binary's run env.

func BinOptTarget ¶ added in v1.4.13

func BinOptTarget(target string) BinOpt

BinOptTarget sets path to compilation target.

func ComposeComposer ¶

func ComposeComposer(compose *Compose) ComposeOpt

ComposeComposer allows getting access to compose instance which is usable after Init() is called.

package main

import (
	"context"

	it "github.com/elisasre/go-common/integrationtest"
)

func main() {
	c := &it.Compose{}

	itr := it.NewIntegrationTestRunner(
		it.OptCompose("docker-compose.yaml", it.ComposeComposer(c)),
	)

	if err := itr.Init(); err != nil {
		return
	}

	dbContainer, err := c.ServiceContainer(context.Background(), "postgres")
	if err != nil {
		return
	}

	_, _, err = dbContainer.Exec(
		context.Background(),
		[]string{"psql", "-U", "demo", "-d", "demo", "-c", "'SELECT * FROM demo_table'"},
	)
	if err != nil {
		return
	}
}

Output:

func ComposeDownOptions ¶

func ComposeDownOptions(opts ...tc.StackDownOption) ComposeOpt

ComposeDownOptions set options for compose.Down().

func ComposeEnv ¶

func ComposeEnv(env map[string]string) ComposeOpt

ComposeEnv set environment variables for compose.

func ComposeOsEnv ¶

func ComposeOsEnv() ComposeOpt

ComposeOsEnv passes environment from OS to compose.

func ComposeUpOptions ¶

func ComposeUpOptions(opts ...tc.StackUpOption) ComposeOpt

ComposeUpOptions set options for compose.Up().

func ComposeWaitForService ¶

func ComposeWaitForService(service string, strategy wait.Strategy) ComposeOpt

ComposeWaitForService makes compose up wait for specific service with given strategy.

func NewIntegrationTestRunner ¶

func NewIntegrationTestRunner(opts ...Opt) *IntegrationTestRunner

NewIntegrationTestRunner creates new IntegrationTestRunner with given options.

func OptBase ¶

func OptBase(base string) Opt

OptBase sets execution base path IntegrationTestRunner. OptBase should be usually the first option when passing options to NewIntegrationTestRunner.

func OptBuildArgs ¶

func OptBuildArgs(args ...string) Opt

OptBuildArgs adds args to build arguments for test binary.

func OptBuildEnv ¶

func OptBuildEnv(env ...string) Opt

OptBuildEnv adds env to test binary's build env.

func OptCompose ¶

func OptCompose(composeFile string, opts ...ComposeOpt) Opt

OptCompose adds docker compose stack as pre condition for tests to run.

func OptCoverDir ¶

func OptCoverDir(coverDir string) Opt

OptCoverDir sets coverage directory for test binary.

func OptFuncRunner ¶ added in v1.4.3

func OptFuncRunner(fn func() error) Opt

OptFuncRunner allows wrapping any function as testRunner function. This can be useful injecting code between ready and test code. Example TestMain:

func TestMain(m *testing.M) {
	itr := it.NewIntegrationTestRunner(
		it.OptBase("../"),
		it.OptTarget("./cmd/app"),
		it.OptCompose("docker-compose.yaml"),
		it.OptWaitHTTPReady("http://127.0.0.1:8080", time.Second*10),
		it.OptFuncRunner(func() error {
			if err := initStuff(); err != nil {
				return err
			}
			if code := m.Run(); code != 0 {
				return errors.New("tests have failed")
			}
			return nil
		}),
	)
	if err := itr.InitAndRun(); err != nil {
		log.Fatal(err)
	}
}

Before using this pattern be sure to read how TestMain should be used!

func OptOutput ¶

func OptOutput(output string) Opt

OptOutput sets output for compilation target.

func OptPreHandler ¶ added in v1.4.2

func OptPreHandler(h PreHandler) Opt

OptPreHandler adds handler as pre condition for tests to run.

func OptPreHandlerFn ¶ added in v1.4.2

func OptPreHandlerFn(run, stop func() error) Opt

OptPreHandlerFn wraps functions as PreHandler and set's it as a pre condition for tests to run.

func OptRunArgs ¶

func OptRunArgs(args ...string) Opt

OptRunArgs adds args to run arguments for test binary.

func OptRunEnv ¶

func OptRunEnv(env ...string) Opt

OptRunEnv adds env to test binary's run env.

func OptTarget ¶

func OptTarget(target string) Opt

OptTarget sets path to compilation target.

func OptTestFunc ¶

func OptTestFunc(t *testing.T, fn func(*testing.T)) Opt

OptTestFunc allows wrapping testing.T into IntegrationTestRunner. Example TestApp:

func TestApp(t *testing.T) {
	itr := it.NewIntegrationTestRunner(
		it.OptBase("../"),
		it.OptTarget("./cmd/app"),
		it.OptCompose("docker-compose.yaml"),
		it.OptWaitHTTPReady("http://127.0.0.1:8080", time.Second*10),
		it.OptTestFunc(t, testApp),
	)
	if err := itr.InitAndRun(); err != nil {
		t.Fatal(err)
	}
}

func testApp(t *testing.T) {
	// run tests here
}

This pattern allows setting the env for each test separately.

func OptTestMain ¶

func OptTestMain(m *testing.M) Opt

OptTestMain allows wrapping testing.M into IntegrationTestRunner. Example TestMain:

func TestMain(m *testing.M) {
	itr := it.NewIntegrationTestRunner(
		it.OptBase("../"),
		it.OptTarget("./cmd/app"),
		it.OptCompose("docker-compose.yaml"),
		it.OptWaitHTTPReady("http://127.0.0.1:8080", time.Second*10),
		it.OptTestMain(m),
	)
	if err := itr.InitAndRun(); err != nil {
		log.Fatal(err)
	}
}

Before using this pattern be sure to read how TestMain should be used!

func OptWaitHTTPReady ¶

func OptWaitHTTPReady(url string, timeout time.Duration) Opt

OptWaitHTTPReady expects 200 OK from given url before tests can be started.