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
+<hr />
-This function expects the SQL query, the example response object, and an optional primary key to set. 
 
-<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 {
+func RandomGenerate(m Config) (*Mock, error)
-    Field1 string `db:"field1" test:"key"`
-}
 ```
 
-## Example
+<hr />
-```go
-func Test() {
-    testArg := 123
-    query := `SELECT ...`
-    type results struct {
-        Field1 string   `db:"field1" test:"key"`
-        Field2 int      `db:"field2"`
-    }
 
-    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)
     }
-
+    rows := sqlmock.NewRows(mock.Columns).AddRows(mock.Rows...)
-    //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
+    sqlmock.ExpectQuery(mock.Query).WithArgs(1, 6).WillReturnRows(rows)
-    rows := sqlmock.NewRows(rando.Columns).AddRow(rando.Rows...)
-    mock.ExpectQuery(rando.Query).WithArgs(testArg).WillReturnRows(rows)
 
     ...
+
 }
 ```
+#### Example of mocked rows from ExampleTest
+|key|count|
+|---|-----|
+|1|649018089772805963|
+|6|1066940846275557682|

lazy.go

@@ -11,51 +11,95 @@ import (
 	"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
+)
+
+// 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) {
+// configuration for RandomGenerate
-	if exampleObj == nil {
+type Config struct {
-		return nil, errors.New("exampleObj cannot be nil")
+	Query    string
+	Example  any
+	Keys     []any //length of keys must = RowCount, if set
+	RowCount int
 }
 
-	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" {
+			//if field has lazy:"key" tag and tags are present inject primary key
-			rows = append(rows, keyVal)
+			if field.Tag.Get(LAZY_TAG) == KEY_VALUE && primaryKey {
+				rows[y] = append(rows[y], m.Keys[y])
 				continue
 			}
 
+			//generate random values
 			nv := kindToRandom(field)
 			if nv == nil {
 				return nil, fmt.Errorf("could not match type: %s", retType.Name())
 			}
 
-		rows = append(rows, nv)
+			rows[y] = append(rows[y], nv)
+		}
 	}
 
-	return &MockResults{
+	return &Mock{
-		Query:   sqlx.Rebind(sqlx.AT, regexp.QuoteMeta(query)),
+		//sql is rebound and escaped for sqlmock.ExpectQuery
+		Query:   sqlx.Rebind(sqlx.AT, 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 {
 	kind := field.Type.Kind()
 	switch kind {
@@ -73,23 +117,99 @@ func kindToRandom(field reflect.StructField) any {
 		return fmt.Sprintf("%d", rand.Int())
 	case reflect.Bool:
 		return rand.Int()%2 == 0
-	case reflect.Slice:
+	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("%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
 		}
 	}