2

I want to write an integration test which tests writing and reading data to and from a database. In order to do this, I need my first test function to connect and prepare a test database; and if that is a success, let the other tests run, which will then be doing queries on it.

So I implemented a TestMain(m *testing.M) which creates a database and runs migrations on it, and if there's no errors, I run m.Run().

But it doesn't have any m.Print or m.Fatal methods like testing.T does. And if I try to log something with log.Print(), it doesn't get output (probably because no testing could have been properly marked as failing).

And the reason why I don't like the creation of the database with a regular test function, is because a regular test of course cannot stop other tests from running, so all my other tests from that file will run and plague the output messages, since they will all fail.

So how do I log something out from TestMain? My TestMain can still fail in multiple ways, and i would like to see in the output what it was.

Example to show TestMain's output not being displayed:

$ ls
go.mod      main_test.go
$ cat go.mod
module App

go 1.16
$ cat main_test.go 
package main

import (
    "testing"
    "log"
)

func TestMain(m *testing.M) {
    log.Print("hello")
}
$ go test ./.
ok      App 0.147s
$
Digital Ninja
  • 3,415
  • 5
  • 26
  • 51
  • `log.Print()` will work from `TestMain()` - and output by default to stdout as expected. Are you setting the log's `io.Writer` to some other location earlier? – colm.anseo Mar 17 '22 at 23:49
  • @colm.anseo I did not. `TestMain`'s output will only be shown if it does in fact allow other tests to run, and they mark it as failed. But in this case, i wouldn't want any other tests in the file to run, I want to log output from `TestMain` and then *not* call `m.Run()`. Is that not the case when you tried it out? Post edited to show minimum reproducible example. – Digital Ninja Mar 18 '22 at 00:31

2 Answers2

1

You need the -v flag:

go test -v .

Note: . is equivalent to ./.

If you want to run tests on all sub-directories use ./... like so:

go test -v ./...

Why is this? Since you are running tests in what's call package list mode (i.e. ./.) - from the docs in go help test:

In this (package list) mode, go test compiles and tests each of the packages listed on the command line. If a package test passes, go test prints only the final 'ok' summary line. If a package test fails, go test prints the full test output.

This is the behavior you have noted. Reading further:

... If invoked with the -bench or -v flag, go test prints the full output even for passing package tests, in order to display the requested benchmark results or verbose logging.

Note: go test alone (i.e. no package list) will allow output logging from TestMain like log.Print.

EDIT here's how I typically do pre-flight setup for my tests:

var testDB     *pgxpool.Pool // all tests should use this

func createDBconn() (*pgxpool.Pool, error) {
    // read ENV VARs - establish connection
    // ...
    return dbconn, nil
}

func TestMain(m *testing.M) {
    var err error
    
    testDB, err = createDBconn()
    if err != nil {
        log.Fatal(err)
    }

    // call flag.Parse() here if TestMain uses flags
    os.Exit(m.Run())
}

if any of the prep fails, then log.Fatal ensures the reason is logged & the program terminates.

colm.anseo
  • 19,337
  • 4
  • 43
  • 52
  • Thank you for the answer, this does indeed let me read the error message. However it requires a compromise, since the output will now be much larger with all the successful outputs as well, while this particular message may be hard to notice, as it doesn't actually say that it had failed. Playing around with it some more, I have found that what seems to solve this situation more elegantly is doing `os.Exit(1)` after my `log.Print`; that way Go knows the test had failed, and does print out the log message, no `-v` flag needed. – Digital Ninja Mar 18 '22 at 09:00
  • @DigitalNinja I updated to include an example of how I do pre-flight setup & use `log.Fatal` to ensure proper logging & termination. – colm.anseo Mar 18 '22 at 21:31
1

It seems that messages printed with log.Print() will display if the test exits with a non-zero code, so this situation is best solved by exiting with non-zero right after the log line, like so:

log.Print("setup of database has failed")
os.Exit(1)
Digital Ninja
  • 3,415
  • 5
  • 26
  • 51