Add Data assets

Many tests require temporary resources (Dockerfiles, compose.yml, etc), and routinely
redo the same thing over and over (create separate temp dir, write file, remove temp dir).
At best this adds a lot of boilerplate / helper functions to the test - at worst, the resources
are not properly cleaned-up, or not well isolated from other test.

This changeset introduces Data helpers to take care of these (AssetSave, AssetLoad, AssetPath).

Signed-off-by: apostasie <[email protected]>

Author: apostasie

mod/tigron/expect/comparators.go

@@ -79,7 +79,7 @@ func JSON[T any](obj T, verifier func(T, string, tig.T)) test.Comparator {
 		t.Helper()
 
 		err := json.Unmarshal([]byte(stdout), &obj)
-		assertive.ErrorIsNil(assertive.WithFailLater(t), err, "Unmarshalling JSON from stdout must succeed")
+		assertive.ErrorIsNil(assertive.WithSilentSuccess(t), err, "Unmarshalling JSON from stdout must succeed")
 
 		if verifier != nil && err == nil {
 			verifier(obj, "Inspecting output (JSON)", t)

mod/tigron/internal/assertive/assertive.go

@@ -165,6 +165,7 @@ func True(testing tig.T, comp bool, msg ...string) bool {
 // Failing later is necessary when asserting inside go routines, and also if you want many
 // successive asserts to all
 // evaluate instead of stopping at the first failing one.
+// FIXME: it should be possible to have both WithFailLater and WithSilentSuccess at the same time.
 func WithFailLater(t tig.T) tig.T {
 	return &failLater{
 		t,

mod/tigron/test/command.go

@@ -191,6 +191,7 @@ func (gc *GenericCommand) Run(expect *Expected) {
 			debug = append(debug, []any{"Signal", result.Signal.String()})
 		}
 
+		// FIXME: wire this
 		if gc.fullDebug {
 			debug = append(debug,
 				[]any{"Environ", strings.Join(result.Environ, "\n")},
@@ -199,12 +200,13 @@ func (gc *GenericCommand) Run(expect *Expected) {
 	}
 
 	// FIXME: wire this so that we can get the environ display back in
-	if gc.fullDebug {
-		debug = append(debug,
-			[]any{"Dir", gc.cmd.WorkingDir},
-			[]any{"Limit", gc.cmd.Timeout},
-		)
-	}
+	// FIXME: we should also be able to inspect `test.Config` and `test.Data` (especially with assets)
+	// if gc.fullDebug {
+	debug = append(debug,
+		[]any{"Dir", gc.cmd.WorkingDir},
+		[]any{"Limit", gc.cmd.Timeout},
+	)
+	// }
 
 	gc.t.Log("\n\n" + formatter.Table(debug, "-") + "\n")
 

mod/tigron/test/consts.go

@@ -0,0 +1,26 @@
+/*
+   Copyright The containerd Authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package test
+
+const (
+	// FilePermissionsDefault specifies the default creation mode for temporary files.
+	// Note that umask will affect these.
+	FilePermissionsDefault = 0o644
+	// DirPermissionsDefault specifies the default creation mode for temporary directories.
+	// Note that umask will affect these.
+	DirPermissionsDefault = 0o755
+)

mod/tigron/test/data.go

@@ -19,9 +19,13 @@ package test
 import (
 	"crypto/sha256"
 	"fmt"
+	"os"
+	"path/filepath"
 	"regexp"
 	"strings"
-	"testing"
+
+	"github.com/containerd/nerdctl/mod/tigron/internal/assertive"
+	"github.com/containerd/nerdctl/mod/tigron/tig"
 )
 
 const (
@@ -38,26 +42,49 @@ func WithData(key, value string) Data {
 	return dat
 }
 
-// Contains the implementation of the Data interface.
-func configureData(t *testing.T, seedData, parent Data) Data {
+// Contains the implementation of the Data interface
+//
+//nolint:varnamelen
+func configureData(t tig.T, seedData, parent Data) Data {
 	t.Helper()
 
+	silentT := assertive.WithSilentSuccess(t)
+
 	if seedData == nil {
 		seedData = &data{}
 	}
 
-	//nolint:forcetypeassert
+	var labels map[string]string
+	if castData, ok := seedData.(*data); ok {
+		labels = castData.labels
+	}
+
 	dat := &data{
 		// Note: implementation dependent
-		labels:  seedData.(*data).labels,
-		tempDir: t.TempDir(),
+		labels: labels,
 		testID: func(suffix ...string) string {
 			suffix = append([]string{t.Name()}, suffix...)
 
 			return defaultIdentifierHashing(suffix...)
 		},
+		t: silentT,
 	}
 
+	// NOTE: certain systems will use the path dirname to decide how they name resources.
+	// t.TempDir() will always return /tmp/TestTempDir2153252249/001, meaning these systems will all
+	// use the identical 001 part. This is true for compose specifically.
+	// Appending the base test identifier here would guarantee better unicity.
+	// Note though that Windows will barf if >256 characters, so, hashing...
+	// Small caveat: identically named tests in different modules WILL still end-up with the same last segment.
+	tempDir := filepath.Join(
+		t.TempDir(),
+		fmt.Sprintf("%x", sha256.Sum256([]byte(t.Name())))[0:identifierSignatureLength],
+	)
+
+	assertive.ErrorIsNil(silentT, os.MkdirAll(tempDir, DirPermissionsDefault))
+
+	dat.tempDir = tempDir
+
 	if parent != nil {
 		dat.adopt(parent)
 	}
@@ -69,6 +96,7 @@ type data struct {
 	labels  map[string]string
 	testID  func(suffix ...string) string
 	tempDir string
+	t       tig.T
 }
 
 func (dt *data) Get(key string) string {
@@ -85,6 +113,31 @@ func (dt *data) Set(key, value string) Data {
 	return dt
 }
 
+func (dt *data) AssetLoad(key string) string {
+	//nolint:gosec
+	content, err := os.ReadFile(filepath.Join(dt.tempDir, key))
+
+	assertive.ErrorIsNil(dt.t, err)
+
+	return string(content)
+}
+
+func (dt *data) AssetSave(key, value string) Data {
+	err := os.WriteFile(
+		filepath.Join(dt.tempDir, key),
+		[]byte(value),
+		FilePermissionsDefault,
+	)
+
+	assertive.ErrorIsNil(dt.t, err)
+
+	return dt
+}
+
+func (dt *data) AssetPath(key string) string {
+	return filepath.Join(dt.tempDir, key)
+}
+
 func (dt *data) Identifier(suffix ...string) string {
 	return dt.testID(suffix...)
 }

mod/tigron/test/data_test.go

@@ -34,6 +34,23 @@ func TestDataBasic(t *testing.T) {
 
 	dataObj.Set("test", "set")
 	assertive.IsEqual(t, dataObj.Get("test"), "set")
+
+	t.Run("verify that (parallel) subtest can access parent data", func(t *testing.T) {
+		t.Parallel()
+
+		assertive.IsEqual(t, dataObj.Get("doesnotexist"), "")
+		// NOTE: this is really tricky. Test being parallel means it will execute once the parent is done.
+		assertive.IsEqual(t, dataObj.Get("test"), "setagain")
+	})
+
+	//nolint:paralleltest
+	t.Run("verify that (non-parallel) subtest can access parent data", func(t *testing.T) {
+		assertive.IsEqual(t, dataObj.Get("doesnotexist"), "")
+		assertive.IsEqual(t, dataObj.Get("test"), "set")
+	})
+
+	dataObj.Set("test", "setagain")
+	assertive.IsEqual(t, dataObj.Get("test"), "setagain")
 }
 
 func TestDataTempDir(t *testing.T) {
@@ -46,6 +63,14 @@ func TestDataTempDir(t *testing.T) {
 
 	assertive.IsEqual(t, one, two)
 	assertive.IsNotEqual(t, one, "")
+
+	t.Run("verify that subtest has an independent TempDir", func(t *testing.T) {
+		t.Parallel()
+
+		dataObj = configureData(t, nil, nil)
+		three := dataObj.TempDir()
+		assertive.IsNotEqual(t, one, three)
+	})
 }
 
 func TestDataIdentifier(t *testing.T) {

mod/tigron/test/funct.go

@@ -25,8 +25,11 @@ type Evaluator func(data Data, helpers Helpers) (bool, string)
 // or Requirement.
 type Butler func(data Data, helpers Helpers)
 
+// TODO: when we will break API:
+// - remove the info parameter
+// - move to tig.T
+
 // A Comparator is the function signature to implement for the Output property of an Expected.
-// TODO: when we will break API, remove the info parameter.
 type Comparator func(stdout, info string, t *testing.T)
 
 // A Manager is the function signature meant to produce expectations for a command.

mod/tigron/test/interfaces.go

@@ -28,13 +28,20 @@ import (
 // test data - second, some commonly useful immutable test properties (a way to generate unique
 // identifiers for that test, temporary directory, etc.)
 // Note that Data is inherited, from parent test to subtest (except for Identifier and TempDir of
-// course).
+// course - along with Assets, which are private as well).
 type Data interface {
 	// Get returns the value of a certain key for custom data
 	Get(key string) string
 	// Set will save `value` for `key`
 	Set(key, value string) Data
 
+	// AssetSave will store data on the filesystem, inside the test private temp directory
+	AssetSave(key, value string) Data
+	// AssetLoad will retrieve previously stored data from the filesystem
+	AssetLoad(key string) string
+	// AssetPath will return the absolute path for the asset
+	AssetPath(key string) string
+
 	// Identifier returns the test identifier that can be used to name resources
 	Identifier(suffix ...string) string
 	// TempDir returns the test temporary directory