Merge pull request 'new/null-types' (#2) from new/null-types into main

Reviewed-on: #2

.gitignore

@@ -15,13 +15,7 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# Go workspace file
-go.work
-go.work.sum
-
 # env file
 .env
 
+cmd/*

README.md

@@ -1,40 +1,93 @@
 # lazy
 
-Lazy is a helper tool when working with SQLx and sqlmock that generates mock data based on the result struct.
+Lazy is a helper tool when working with [sqlx](https://github.com/jmoiron/sqlx) and [sqlmock](https://github.com/DATA-DOG/go-sqlmock) that generates mock data for unit tests based on the example struct.
 
-## GenerateRandomResults
-This function expects the SQL query, the example response object, and an optional primary key to set. 
+<hr />
 
-<b>Query</b> The SQL query argument is taken and rebound using sqlx.AT bindvar type, this allows the returned query to be used directly in a sqlmock [ExpectQuery](https://pkg.go.dev/github.com/data-dog/go-sqlmock#Sqlmock.ExpectQuery) check.
+- [RandomGenerate](#randomgenerate)
+    * [Config](#config)
+    * [Mocks](#mocks)
+    * [Tags](#tags)
+    * [Example](#example)
 
-<b>Example Object</b> The example object argument <u>must</u> be a struct and requires "db" tags. The db tags are then parsed and used to calculate the psuedo-random rows and values
+<hr />
 
-<b>Primary Key</b> The optional primary key argument is used to hardcode a primary key field in the returned mocks, the primary key field in the example struct <u>must</u> have a test tag with the value "key"
+## RandomGenerate
+Generates random data for basic types and slices to be used with [sqlmock](https://github.com/DATA-DOG/go-sqlmock). Slices are given an arbitrary amount entries See [Mocks](#mocks) for more information.
 ```go
-type Mock struct {
-    Field1 string `db:"field1" test:"key"`
-}
+func RandomGenerate(m Config) (*Mock, error)
 ```
 
-## Example
-```go
-func Test() {
-    testArg := 123
-    query := `SELECT ...`
-    type results struct {
-        Field1 string   `db:"field1" test:"key"`
-        Field2 int      `db:"field2"`
-    }
+<hr />
 
-    rando, err := GenerateRandomResults(query, results{}, testArg)
+### Config
+```go
+type Config struct {
+	Query    string
+	Example  any
+	Keys     []any
+	RowCount int
+}
+```
+The Config struct is used to generate the data:
+- <b>Query</b> the sql query that is being run in the function being tested
+- <b>Example</b> represents the struct that will be used in the sql scan, this struct is used to detect which fields are expected in the query. Fields must have "db" tag to be parsed
+- <b>Keys</b> primary keys to be hardcoded in mock rows, if needed. Primary keys are detected by tags in the example struct, see [Tags](#tags) for more information
+- <b>RowCount</b> the amount of mock rows to be generated, if you are setting primary keys this number must be equal to the amount of keys supplied
+
+<hr />
+
+### Mocks
+```go
+type Mock struct {
+	Query   string
+	Columns []string
+	Rows    [][]driver.Value
+}
+```
+The Mock struct is returned by RandomGenerate:
+- <b>Query</b> represents the query string expected by [ExpectQuery](https://pkg.go.dev/github.com/DATA-DOG/go-sqlmock#SqlmockCommon.ExpectQuery). The original query is rebound using the bindvar type [sqlx.AT](https://pkg.go.dev/github.com/jmoiron/sqlx#AT)
+- <b>Columns</b> slice of expected column names for [sqlmock.NewRows](https://pkg.go.dev/github.com/DATA-DOG/go-sqlmock#NewRows)
+- <b>Rows</b> represents the row data for [AddRows](https://pkg.go.dev/github.com/DATA-DOG/go-sqlmock#Rows.AddRows)
+
+<hr />
+
+### Tags
+Struct tags are required on the example struct to generate the data
+- <b>lazy</b> optional, set this tag to <b>key</b> to mark the primary key field on the example struct, if no Keys are provided in the Config struct this tag will be ignored
+- <b>db</b> required for mock columns to be generated, columns will be based on tag value
+
+<hr />
+
+### Example
+This program is a psuedo-code example of the mock generation. It takes the SqlResultsExample and uses it to generate two rows of mock data using the Keys (1, 6) as the Key, signified by the lazy tag. See [Example output](#example-output-rows) for the generated sql rows.
+```go
+func ExampleTest() {
+    ...
+
+    type SqlResultsExample struct {
+        Key     string  `db:"key" lazy:"key"`
+        Count   int     `db:"count"`
+    }
+    cfg := lazy.Config{
+	    Query:      "SELECT key, count FROM table WHERE key IN (?, ?)",
+	    Example:    SqlResultsExample{},
+	    Keys:       []any{ 1, 6 },
+	    RowCount:   2,  
+    }
+    mock, err := lazy.GenerateRandom(cfg)
     if err != nil {
         panic(err)
     }
-
-    //the rando object will now have psuedo random values in all fields except for the field containing the test tag set to "key" that field will be hardcoded with the testArg to allow for unit tests to ensure the requested ID flows through
-    rows := sqlmock.NewRows(rando.Columns).AddRow(rando.Rows...)
-    mock.ExpectQuery(rando.Query).WithArgs(testArg).WillReturnRows(rows)
+    rows := sqlmock.NewRows(mock.Columns).AddRows(mock.Rows...)
+    sqlmock.ExpectQuery(mock.Query).WithArgs(1, 6).WillReturnRows(rows)
 
     ...
+
 }
 ```
+#### Example of mocked rows from ExampleTest
+|key|count|
+|---|-----|
+|1|649018089772805963|
+|6|1066940846275557682|

lazy.go

@@ -1,43 +1,93 @@
 package lazy
 
 import (
+	"database/sql"
 	"database/sql/driver"
 	"errors"
 	"fmt"
 	"math/rand/v2"
 	"reflect"
 	"regexp"
+	"time"
 
 	"github.com/jmoiron/sqlx"
 )
 
-type MockResults struct {
+const (
+	DB_TAG    = "db"   //tag used to parse sql fields in example struct
+	LAZY_TAG  = "lazy" //tag label for KEY_VALUE
+	KEY_VALUE = "key"  //tag value for LAZY_TAG
+	//bind values
+	BindQuestion Binds = 1
+	BindDollar   Binds = 2
+	BindNamed    Binds = 3
+	BindAt       Binds = 4
+)
+
+type Binds int
+
+// mock data generated based on config
+type Mock struct {
 	Query   string
 	Columns []string
-	Rows    []driver.Value
+	Rows    [][]driver.Value
 }
 
-func GenerateRandomResults(query string, exampleObj any, keyVal any) (*MockResults, error) {
-	if exampleObj == nil {
-		return nil, errors.New("exampleObj cannot be nil")
+// configuration for RandomGenerate
+type Config struct {
+	Query    string
+	Example  any
+	Keys     []any //length of keys must = RowCount, if set
+	RowCount int
+	BindType Binds
 }
 
-	retType := reflect.TypeOf(exampleObj)
+// generates mock data based on configuration to be used for sqlmock
+func RandomGenerate(m Config) (*Mock, error) {
+	//example struct cannot be nil and must be a struct
+	if m.Example == nil {
+		return nil, errors.New("example value cannot be nil")
+	}
+	if reflect.ValueOf(m.Example).Kind() != reflect.Struct {
+		return nil, errors.New("example value must be a struct")
+	}
+
+	//any weirdness, just pull one row
+	if m.RowCount <= 0 {
+		m.RowCount = 1
+	}
+
+	//if keys are set, ensure there are enough to populate requested rows
+	primaryKey := false
+	if len(m.Keys) > 0 {
+		primaryKey = true
+		if len(m.Keys) != m.RowCount {
+			return nil, errors.New("you must provide a key for each row")
+		}
+	}
+
+	retType := reflect.TypeOf(m.Example)
 	maxFieldCount := retType.NumField()
 	columns := make([]string, 0, maxFieldCount)
-	rows := make([]driver.Value, 0, maxFieldCount)
+	rows := make([][]driver.Value, 0)
 
+	for y := 0; y < m.RowCount; y++ {
+		rows = append(rows, make([]driver.Value, 0))
 		for x := 0; x < maxFieldCount; x++ {
 			field := retType.Field(x)
-		dbTag := field.Tag.Get("db")
+			dbTag := field.Tag.Get(DB_TAG)
 			if dbTag == "" {
 				continue
 			}
 
+			//track columns only once
+			if y == 0 {
 				columns = append(columns, dbTag)
+			}
 
-		if field.Tag.Get("test") == "key" {
-			rows = append(rows, keyVal)
+			//if field has lazy:"key" tag and tags are present inject primary key
+			if field.Tag.Get(LAZY_TAG) == KEY_VALUE && primaryKey {
+				rows[y] = append(rows[y], m.Keys[y])
 				continue
 			}
 
@@ -46,17 +96,85 @@ func GenerateRandomResults(query string, exampleObj any, keyVal any) (*MockResul
 				return nil, fmt.Errorf("could not match type: %s", retType.Name())
 			}
 
-		rows = append(rows, nv)
+			rows[y] = append(rows[y], nv)
+		}
 	}
 
-	return &MockResults{
-		Query:   sqlx.Rebind(sqlx.AT, regexp.QuoteMeta(query)),
+	return &Mock{
+		//sql is rebound and escaped for sqlmock.ExpectQuery
+		Query:   sqlx.Rebind(int(m.BindType), regexp.QuoteMeta(m.Query)),
 		Columns: columns,
 		Rows:    rows,
 	}, nil
 }
 
+// converts basic reflect Kind's to psuedo-random data, slices are given a random amount of entries
 func kindToRandom(field reflect.StructField) any {
+	//this isn't ideal, but since the sql types are structs they were being filled in a weird
+	//manner. For now we check those types first, and will clean this up later.
+	switch field.Type {
+	case reflect.TypeOf(sql.NullTime{}):
+		var temp sql.NullTime
+		if !isNull() {
+			temp.Valid = true
+			temp.Time = time.Now()
+		}
+		return temp
+	case reflect.TypeOf(sql.NullInt16{}):
+		var temp sql.NullInt16
+		if isNull() {
+			temp.Valid = false
+		} else {
+			temp.Valid = true
+			temp.Int16 = int16(rand.Int())
+		}
+		return temp
+	case reflect.TypeOf(sql.NullInt32{}):
+		var temp sql.NullInt32
+		if isNull() {
+			temp.Valid = false
+		} else {
+			temp.Valid = true
+			temp.Int32 = rand.Int32()
+		}
+		return temp
+	case reflect.TypeOf(sql.NullInt64{}):
+		var temp sql.NullInt64
+		if isNull() {
+			temp.Valid = false
+		} else {
+			temp.Valid = true
+			temp.Int64 = rand.Int64()
+		}
+		return temp
+	case reflect.TypeOf(sql.NullBool{}):
+		var temp sql.NullBool
+		if isNull() {
+			temp.Valid = false
+		} else {
+			temp.Valid = true
+			temp.Bool = (rand.Int()%2 == 0)
+		}
+		return temp
+	case reflect.TypeOf(sql.NullFloat64{}):
+		var temp sql.NullFloat64
+		if isNull() {
+			temp.Valid = false
+		} else {
+			temp.Valid = true
+			temp.Float64 = rand.Float64()
+		}
+		return temp
+	case reflect.TypeOf(sql.NullString{}):
+		var temp sql.NullString
+		if isNull() {
+			temp.Valid = false
+		} else {
+			temp.Valid = true
+			temp.String = fmt.Sprintf("random %d", rand.Int())
+		}
+		return temp
+	}
 	kind := field.Type.Kind()
 	switch kind {
 	case reflect.Int:
@@ -70,28 +188,117 @@ func kindToRandom(field reflect.StructField) any {
 	case reflect.Float64:
 		return rand.Float64()
 	case reflect.String:
-		return fmt.Sprintf("%d", rand.Int())
+		return fmt.Sprintf("random %d", rand.Int())
 	case reflect.Bool:
 		return rand.Int()%2 == 0
-	case reflect.Slice:
+	case reflect.TypeOf(time.Time{}).Kind():
+		return time.Now()
+	case reflect.Array:
 		underlying := field.Type.Elem().Kind()
+		count := reflect.ValueOf(field).Len() //fill entire length
 		switch underlying {
 		case reflect.Int:
-			return []int{rand.Int()}
+			var intslice []int
+			for x := 0; x < count; x++ {
+				intslice = append(intslice, rand.Int())
+			}
+			return intslice
 		case reflect.Int32:
-			return []int32{rand.Int32()}
+			var int32slice []int32
+			for x := 0; x < count; x++ {
+				int32slice = append(int32slice, rand.Int32())
+			}
+			return int32slice
 		case reflect.Int64:
-			return []int64{rand.Int64()}
+			var int64slice []int64
+			for x := 0; x < count; x++ {
+				int64slice = append(int64slice, rand.Int64())
+			}
+			return int64slice
 		case reflect.Float32:
-			return []float32{rand.Float32()}
+			var float32slice []float32
+			for x := 0; x < count; x++ {
+				float32slice = append(float32slice, rand.Float32())
+			}
+			return float32slice
 		case reflect.Float64:
-			return []float64{rand.Float64()}
+			var float64slice []float64
+			for x := 0; x < count; x++ {
+				float64slice = append(float64slice, rand.Float64())
+			}
+			return float64slice
 		case reflect.String:
-			return []string{fmt.Sprintf("%d", rand.Int())}
+			var strslice []string
+			for x := 0; x < count; x++ {
+				strslice = append(strslice, fmt.Sprintf("%d", rand.Int()))
+			}
+			return strslice
 		case reflect.Bool:
-			return []bool{rand.Int()%2 == 0}
+			var boolslice []bool
+			for x := 0; x < count; x++ {
+				boolslice = append(boolslice, (rand.Int()%2 == 0))
+			}
+			return boolslice
+		}
+	case reflect.Slice:
+		underlying := field.Type.Elem().Kind()
+		count := (rand.Int() % 10) + 1 //amount of entries to append to slice
+		switch underlying {
+		case reflect.Int:
+			var intslice []int
+			for x := 0; x < count; x++ {
+				intslice = append(intslice, rand.Int())
+			}
+			return intslice
+		case reflect.Int32:
+			var int32slice []int32
+			for x := 0; x < count; x++ {
+				int32slice = append(int32slice, rand.Int32())
+			}
+			return int32slice
+		case reflect.Int64:
+			var int64slice []int64
+			for x := 0; x < count; x++ {
+				int64slice = append(int64slice, rand.Int64())
+			}
+			return int64slice
+		case reflect.Float32:
+			var float32slice []float32
+			for x := 0; x < count; x++ {
+				float32slice = append(float32slice, rand.Float32())
+			}
+			return float32slice
+		case reflect.Float64:
+			var float64slice []float64
+			for x := 0; x < count; x++ {
+				float64slice = append(float64slice, rand.Float64())
+			}
+			return float64slice
+		case reflect.String:
+			var strslice []string
+			for x := 0; x < count; x++ {
+				strslice = append(strslice, fmt.Sprintf("random %d", rand.Int()))
+			}
+			return strslice
+		case reflect.Bool:
+			var boolslice []bool
+			for x := 0; x < count; x++ {
+				boolslice = append(boolslice, (rand.Int()%2 == 0))
+			}
+			return boolslice
 		}
 	}
 
 	return nil
 }
+
+// a quick and dirty rng function to determine if nulltypes are null or
+// if we will generate a random value
+func isNull() bool {
+	x := rand.IntN(2)
+	if x%2 == 0 {
+		return true
+	} else {
+		return false
+	}
+}