pkg/config/configtest: move package cfgtest from chainlink/v2

Author: jmank88

pkg/config/configtest/configtest.go

@@ -0,0 +1,109 @@
+package configtest
+
+import (
+	"encoding"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/multierr"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/config"
+)
+
+func AssertFieldsNotNil(t *testing.T, s interface{}) {
+	err := assertValNotNil(t, "", reflect.ValueOf(s))
+	_, err = config.MultiErrorList(err)
+	assert.NoError(t, err)
+}
+
+// assertFieldsNotNil recursively checks the struct s for nil fields.
+func assertFieldsNotNil(t *testing.T, prefix string, s reflect.Value) (err error) {
+	t.Helper()
+	require.Equal(t, reflect.Struct, s.Kind())
+
+	typ := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		f := s.Field(i)
+		key := prefix
+		if tf := typ.Field(i); !tf.Anonymous {
+			if key != "" {
+				key += "."
+			}
+			key += tf.Name
+		}
+		err = multierr.Combine(err, assertValNotNil(t, key, f))
+	}
+	return
+}
+
+// assertValuesNotNil recursively checks the map m for nil values.
+func assertValuesNotNil(t *testing.T, prefix string, m reflect.Value) (err error) {
+	t.Helper()
+	require.Equal(t, reflect.Map, m.Kind())
+	if prefix != "" {
+		prefix += "."
+	}
+
+	mi := m.MapRange()
+	for mi.Next() {
+		key := prefix + mi.Key().String()
+		err = multierr.Combine(err, assertValNotNil(t, key, mi.Value()))
+	}
+	return
+}
+
+// assertElementsNotNil recursively checks the slice s for nil values.
+func assertElementsNotNil(t *testing.T, prefix string, s reflect.Value) (err error) {
+	t.Helper()
+	require.Equal(t, reflect.Slice, s.Kind())
+
+	for i := 0; i < s.Len(); i++ {
+		err = multierr.Combine(err, assertValNotNil(t, prefix, s.Index(i)))
+	}
+	return
+}
+
+var (
+	textUnmarshaler     encoding.TextUnmarshaler
+	textUnmarshalerType = reflect.TypeOf(&textUnmarshaler).Elem()
+)
+
+// assertValNotNil recursively checks that val is not nil. val must be a struct, map, slice, or point to one.
+func assertValNotNil(t *testing.T, key string, val reflect.Value) error {
+	t.Helper()
+	k := val.Kind()
+	switch k { //nolint:exhaustive
+	case reflect.Ptr:
+		if val.IsNil() {
+			return fmt.Errorf("%s: nil", key)
+		}
+	}
+	if k == reflect.Ptr {
+		if val.Type().Implements(textUnmarshalerType) {
+			return nil // skip values unmarshaled from strings
+		}
+		val = val.Elem()
+	}
+	switch val.Kind() {
+	case reflect.Struct:
+		if val.Type().Implements(textUnmarshalerType) {
+			return nil // skip values unmarshaled from strings
+		}
+		return assertFieldsNotNil(t, key, val)
+	case reflect.Map:
+		if val.IsNil() {
+			return nil // not actually a problem
+		}
+		return assertValuesNotNil(t, key, val)
+	case reflect.Slice:
+		if val.IsNil() {
+			return nil // not actually a problem
+		}
+		return assertElementsNotNil(t, key, val)
+	default:
+		return nil
+	}
+}

pkg/config/configtest/defaults.go

@@ -0,0 +1,87 @@
+package configtest
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+// DocDefaultsOnly reads only the default values from a docs TOML file and decodes in to cfg.
+// Fields without defaults will set to zero values.
+func DocDefaultsOnly(r io.Reader, cfg any, decode func(io.Reader, any) error) error {
+	pr, pw := io.Pipe()
+	defer pr.Close()
+	go writeDefaults(r, pw)
+	if err := decode(pr, cfg); err != nil {
+		return errors.Wrapf(err, "failed to decode default core configuration")
+	}
+	// replace niled examples with zero values.
+	nilToZero(reflect.ValueOf(cfg))
+	return nil
+}
+
+// writeDefaults writes default lines from defaultsTOML to w.
+func writeDefaults(r io.Reader, w *io.PipeWriter) {
+	defer w.Close()
+	s := bufio.NewScanner(r)
+	for s.Scan() {
+		t := s.Text()
+		// Skip comments and examples (which become zero values)
+		if strings.HasPrefix(t, "#") || strings.HasSuffix(t, "# Example") {
+			continue
+		}
+		if _, err := io.WriteString(w, t); err != nil {
+			w.CloseWithError(err)
+		}
+		if _, err := w.Write([]byte{'\n'}); err != nil {
+			w.CloseWithError(err)
+		}
+	}
+	if err := s.Err(); err != nil {
+		w.CloseWithError(fmt.Errorf("failed to scan core defaults: %w", err))
+	}
+}
+
+func nilToZero(val reflect.Value) {
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			t := val.Type().Elem()
+			val.Set(reflect.New(t))
+		}
+		if val.Type().Implements(textUnmarshalerType) {
+			return // don't descend inside - leave whole zero value
+		}
+		val = val.Elem()
+	}
+	switch val.Kind() {
+	case reflect.Struct:
+		if val.Type().Implements(textUnmarshalerType) {
+			return // skip values unmarshaled from strings
+		}
+		for i := 0; i < val.NumField(); i++ {
+			f := val.Field(i)
+			nilToZero(f)
+		}
+		return
+	case reflect.Map:
+		if !val.IsNil() {
+			for _, k := range val.MapKeys() {
+				nilToZero(val.MapIndex(k))
+			}
+		}
+		return
+	case reflect.Slice:
+		if !val.IsNil() {
+			for i := 0; i < val.Len(); i++ {
+				nilToZero(val.Index(i))
+			}
+		}
+		return
+	default:
+		return
+	}
+}