add unit test to verify subset of fields

Emyrk · Emyrk · commit feebf2b0fbb2 · 2024-10-16T17:21:49.000-05:00
diff --git a/coderd/database/dbgen/dbgen.go b/coderd/database/dbgen/dbgen.go
@@ -232,7 +232,7 @@ func WorkspaceAgentScriptTiming(t testing.TB, db database.Store, orig database.W
 	return timing
 }
 
-func Workspace(t testing.TB, db database.Store, orig database.Workspace) database.Workspace {
+func Workspace(t testing.TB, db database.Store, orig database.WorkspaceTable) database.WorkspaceTable {
 	t.Helper()
 
 	workspace, err := db.InsertWorkspace(genCtx, database.InsertWorkspaceParams{
diff --git a/coderd/database/gentest/models_test.go b/coderd/database/gentest/models_test.go
@@ -65,6 +65,20 @@ func TestViewSubsetWorkspaceBuild(t *testing.T) {
 	}
 }
 
+// TestViewSubsetWorkspace ensures WorkspaceTable is a subset of Workspace
+func TestViewSubsetWorkspace(t *testing.T) {
+	t.Parallel()
+	table := reflect.TypeOf(database.WorkspaceTable{})
+	joined := reflect.TypeOf(database.Workspace{})
+
+	tableFields := allFields(table)
+	joinedFields := allFields(joined)
+	if !assert.Subset(t, fieldNames(joinedFields), fieldNames(tableFields), "table is not subset") {
+		t.Log("Some fields were added to the Workspace Table without updating the 'workspaces_expanded' view.")
+		t.Log("See migration 000262_workspace_with_names.up.sql to create the view.")
+	}
+}
+
 func fieldNames(fields []reflect.StructField) []string {
 	names := make([]string, len(fields))
 	for i, field := range fields {
diff --git a/coderd/database/migrations/000266_workspace_with_names.down.sql b/coderd/database/migrations/000266_workspace_with_names.down.sql
diff --git a/coderd/database/migrations/000266_workspace_with_names.up.sql b/coderd/database/migrations/000266_workspace_with_names.up.sql
diff --git a/coderd/database/modelqueries_internal_test.go b/coderd/database/modelqueries_internal_test.go
@@ -2,10 +2,11 @@ package database
 
 import (
 	"fmt"
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestIsAuthorizedQuery(t *testing.T) {
@@ -22,68 +23,12 @@ func TestWorkspaceTableConvert(t *testing.T) {
 	t.Parallel()
 
 	var workspace Workspace
-	err := populateStruct(&workspace)
+	err := testutil.PopulateStruct(&workspace, nil)
 	require.NoError(t, err)
 
-}
-
-func populateStruct(s interface{}) error {
-	v := reflect.ValueOf(s)
-	if v.Kind() != reflect.Ptr || v.IsNil() {
-		return fmt.Errorf("s must be a non-nil pointer")
-	}
-
-	v = v.Elem()
-	if v.Kind() != reflect.Struct {
-		return fmt.Errorf("s must be a pointer to a struct")
-	}
-
-	t := v.Type()
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		fieldName := field.Name
-
-		fieldValue := v.Field(i)
-		if !fieldValue.CanSet() {
-			continue // Skip if field is unexported
-		}
+	workspace.WorkspaceTable()
+	require.JSONEq(t)
 
-		switch fieldValue.Kind() {
-		case reflect.Struct:
-			if err := populateStruct(fieldValue.Addr().Interface()); err != nil {
-				return fmt.Errorf("%s : %w", fieldName, err)
-			}
-		case reflect.String:
-			fieldValue.SetString("foo")
-		case reflect.Invalid:
-		case reflect.Bool:
-		case reflect.Int:
-		case reflect.Int8:
-		case reflect.Int16:
-		case reflect.Int32:
-		case reflect.Int64:
-		case reflect.Uint:
-		case reflect.Uint8:
-		case reflect.Uint16:
-		case reflect.Uint32:
-		case reflect.Uint64:
-		case reflect.Uintptr:
-		case reflect.Float32:
-		case reflect.Float64:
-		case reflect.Complex64:
-		case reflect.Complex128:
-		case reflect.Array:
-		case reflect.Chan:
-		case reflect.Func:
-		case reflect.Interface:
-		case reflect.Map:
-		case reflect.Pointer:
-		case reflect.Slice:
-		case reflect.UnsafePointer:
-		default:
-			return fmt.Errorf("unsupported kind %s", fieldValue.Kind())
-		}
-	}
+	fmt.Println(workspace)
 
-	return nil
 }
diff --git a/testutil/reflect.go b/testutil/reflect.go
@@ -0,0 +1,139 @@
+package testutil
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+)
+
+type Random struct {
+	String  func() string
+	Bool    func() bool
+	Int     func() int64
+	Uint    func() uint64
+	Float   func() float64
+	Complex func() complex128
+}
+
+func NewRandom() *Random {
+	// Guaranteed to be random...
+	return &Random{
+		String:  func() string { return "foo" },
+		Bool:    func() bool { return true },
+		Int:     func() int64 { return 500 },
+		Uint:    func() uint64 { return 126 },
+		Float:   func() float64 { return 3.14 },
+		Complex: func() complex128 { return 6.24 },
+	}
+}
+
+// PopulateStruct does a best effort to populate a struct with random values.
+func PopulateStruct(s interface{}, r *Random) error {
+	if r == nil {
+		r = NewRandom()
+	}
+
+	v := reflect.ValueOf(s)
+	if v.Kind() != reflect.Ptr || v.IsNil() {
+		return fmt.Errorf("s must be a non-nil pointer")
+	}
+
+	v = v.Elem()
+	if v.Kind() != reflect.Struct {
+		return fmt.Errorf("s must be a pointer to a struct")
+	}
+
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		fieldName := field.Name
+
+		fieldValue := v.Field(i)
+		if !fieldValue.CanSet() {
+			continue // Skip if field is unexported
+		}
+
+		nv, err := populateValue(fieldValue, r)
+		if err != nil {
+			return fmt.Errorf("%s : %w", fieldName, err)
+		}
+		v.Field(i).Set(nv)
+	}
+
+	return nil
+}
+
+func populateValue(v reflect.Value, r *Random) (reflect.Value, error) {
+	var err error
+
+	// Handle some special cases
+	switch v.Type() {
+	case reflect.TypeOf(time.Time{}):
+		v.Set(reflect.ValueOf(time.Date(2020, 5, 2, 5, 19, 21, 30, time.UTC)))
+		return v, nil
+	}
+
+	switch v.Kind() {
+	case reflect.Struct:
+		if err := PopulateStruct(v.Addr().Interface(), r); err != nil {
+			return v, err
+		}
+	case reflect.String:
+		v.SetString(r.String())
+	case reflect.Bool:
+		v.SetBool(true)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		v.SetInt(r.Int())
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		v.SetUint(r.Uint())
+	case reflect.Float32, reflect.Float64:
+		v.SetFloat(r.Float())
+	case reflect.Complex64, reflect.Complex128:
+		v.SetComplex(r.Complex())
+	case reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			nv, err := populateValue(v.Index(i), r)
+			if err != nil {
+				return v, fmt.Errorf("array index %d : %w", i, err)
+			}
+			v.Index(i).Set(nv)
+		}
+	case reflect.Map:
+		m := reflect.MakeMap(v.Type())
+
+		// Set a value in the map
+		k := reflect.New(v.Type().Key())
+		kv := reflect.New(v.Type().Elem())
+		k, err = populateValue(k, r)
+		if err != nil {
+			return v, fmt.Errorf("map key : %w", err)
+		}
+		kv, err = populateValue(kv, r)
+		if err != nil {
+			return v, fmt.Errorf("map value : %w", err)
+		}
+
+		m.SetMapIndex(k, kv)
+		return m, nil
+	case reflect.Pointer:
+		return populateValue(v.Elem(), r)
+	case reflect.Slice:
+		s := reflect.MakeSlice(v.Type(), 2, 2)
+		sv, err := populateValue(reflect.New(v.Type().Elem()), r)
+		if err != nil {
+			return v, fmt.Errorf("slice value : %w", err)
+		}
+
+		s.Index(0).Set(sv)
+		s.Index(1).Set(sv)
+		//reflect.AppendSlice(s, sv)
+
+		return s, nil
+	case reflect.Uintptr, reflect.UnsafePointer, reflect.Chan, reflect.Func, reflect.Interface:
+		// Unsupported
+		return v, fmt.Errorf("%s is not supported", v.Kind())
+	default:
+		return v, fmt.Errorf("unsupported kind %s", v.Kind())
+	}
+	return v, nil
+}

Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ func WorkspaceAgentScriptTiming(t testing.TB, db database.Store, orig database.W`
`232`	`232`	`return timing`
`233`	`233`	`}`
`234`	`234`
`235`		`-func Workspace(t testing.TB, db database.Store, orig database.Workspace) database.Workspace {`
	`235`	`+func Workspace(t testing.TB, db database.Store, orig database.WorkspaceTable) database.WorkspaceTable {`
`236`	`236`	`t.Helper()`
`237`	`237`
`238`	`238`	`workspace, err := db.InsertWorkspace(genCtx, database.InsertWorkspaceParams{`