How to share Golang package test data files with consumers? - go

Question

We've created a private go library (utility package) to share common api methods and business logic among services. In the utility package we have dozens of mock JSON responses in '.json' files, for mock api testing.
The services consuming this utility package would also like to access the same mock files, as they rely on the same mock api responses to test various internal business logic. Is there a way I can share these files, either by some relative file path, or precompiling them (bytes or strings) to allow consumer tests to reference the same .json files (filepath or data) via standard pkg variables or methods, after importing via go get github.com/whatever/utility-library?
Ideally, consumer tests can access these files via a sub package (like "http/httptest"), and then reference the internal .json files in their own mock servers (like httptest.GetBusinessObject.Response []byte or ResponseFilePath string, etc). We want to continue storing the mock responses in .json files, within the same utility module, but simply expose them to consumer test files, strictly for testing purposes.
my-api-pkg
├── go.mod
└── api
└── api.go
└── api_test.go // <= we currently access .json files here like utiltest.apiResponse []byte
└── apitest // <= sub pkg that contains testing methods and .json accessors
└── apitest.go
└── responses
└── api.response.json
my-service-pkg
├── go.mod
├── server.go
├── server_test.go
└── sub-pkg
└── subpkg.go
└── subpkg_test.go // <= want to access utiltest.apiResponse []byte for api mocks here

Answer 1

Non-Go files and _test.go files are not compiled into a module. To publish _test.go files, rename them to .go files and export the variables and functions that you want to expose to your clients.
For non-Go files, as of Go 1.16, embed them:
package mycompany.com/common/testing
import _ "embed"
//go:embed responses/api.response.json
var MockApiJsonResponse []byte // or string
where the directory tree looks like:
testing
└── testing.go
└── responses
└── api.response.json
Then your clients will be able to reference those exported variables and functions as usual:
package mycompany.com/service
import (
"testing"
common_testing "mycompany.com/common/testing"
)
func TestThings(t *testing.T) {
mock := common_testing.MockApiJsonResponse
// ...
}

Answer 2

OP Answer! It appears my issue was that there was a single imported utility fn in my apitest package, from it's own internal testing.go file, which meant it's init() function was running and polluting the upstream pkg test runs.
My initial approach was sound, but the erptest pkg was no longer being downloaded to upstream services after I removed it's internal testing.go import. I changed the structure to reference a testing directory at the root like so, which restored the upsrtream downloads of the apitest pkg:
/my-api-pkg
├── go.mod
└── /api
└── api.go
└── api_test.go // <= we currently access .json files here like utiltest.apiResponse []byte
└── /apitest // <= sub pkg that contains testing methods and .json accessors
└── apitest.go
└── /testing // <= moving the files here re-enabled download and access or erptest code to upstream consumers
└── /files
└── /api.response.json
Here's the basic structure of my apitest pkg exports, to enable access to the files (as []byte) upstream via apitest.Domain().GetApiRoute1.Res1
// accessor
type domainAccessor struct {
GetApiRoute1 getApiRoute1
...
}
func DomainAccessor() domainAccessor {
return domainAccessor{
GetApiRoute1: _GetApiRoute1,
...
}
}
// individual file accessors for each route
type getApiRoute1 struct {
Res1 []byte
Res2 []byte
}
var _GetApiRoute1 = getApiRoute1{
Res1: loadFile("testing/files/api/v1/domain/getApiRoute1.res.json"),
Res2: loadFile("testing/files/api/v1/domain/getApiRoute2.res.json"),
}
The loadfile fn to read the files to []byte
func loadFile(filepath string) []byte {
dir := ""
_, filename, _, ok := runtime.Caller(0)
if ok {
dir = path.Join(path.Dir(filename), "..", "..", "..")
}
fullPath := path.Join(dir, filepath)
body, err := ioutil.ReadFile(fullPath)
if err != nil {
log.Println("Error apitest.loadFile: unable to read file", err)
panic(err)
}
return body
}