Add bool access tests (#15)

* feat: add unit tests for access_bool.go

Adds unit tests for the booleanAccess struct in access_bool.go.
Creates a new test file access_bool_test.go and adds tests for various methods of booleanAccess like NewBooleanAccess, ValueToInsert, Equals, And, Get, AppendScannable, FieldValueToScan, and TableAlias.

Also adds a helper SQL() method to booleanAccess to facilitate testing.

* feat: add unit tests for access_bool.go and access_float.go

This commit adds unit tests for the `booleanAccess` and `float64Access` structs.

- Creates new test files `access_bool_test.go` and `access_float_test.go`.
- Adds tests for various methods of `booleanAccess` and `float64Access`.
- Adds a helper `SQL()` method to both `booleanAccess` and `float64Access` to facilitate testing.

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: emicklei

access_bool.go

@@ -1,5 +1,7 @@
 package pgtalk
 
+import "bytes"
+
 type booleanAccess struct {
 	unimplementedBooleanExpression
 	ColumnInfo
@@ -21,6 +23,13 @@ func (a booleanAccess) ValueToInsert() any {
 	return a.valueToInsert
 }
 
+func (a booleanAccess) SQL() string {
+	buf := new(bytes.Buffer)
+	w := NewWriteContext(buf)
+	a.SQLOn(w)
+	return buf.String()
+}
+
 func (a booleanAccess) And(e SQLExpression) SQLExpression {
 	return makeBinaryOperator(a, "AND", e)
 }

access_bool_test.go

@@ -0,0 +1,78 @@
+package pgtalk
+
+import (
+	"testing"
+)
+
+func TestNewBooleanAccess(t *testing.T) {
+	info := MakeColumnInfo(boolTable, "fbool", NotPrimary, Nullable, 1)
+	a := NewBooleanAccess(info, func(dest any) any { return &dest.(*poly).FBool })
+	if got, want := a.Column().columnName, "fbool"; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+var boolTable = TableInfo{Name: "boolies", Schema: "public", Alias: "b1"}
+
+var polyFBool = NewBooleanAccess(MakeColumnInfo(boolTable, "fbool", NotPrimary, Nullable, 1),
+	func(dest any) any { return &dest.(*poly).FBool })
+
+func TestBooleanAccess_ValueToInsert(t *testing.T) {
+	a := polyFBool.Set(true)
+	if got, want := a.ValueToInsert(), true; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestBooleanAccess_Equals(t *testing.T) {
+	a := polyFBool.Equals(true)
+	sql := SQL(a)
+	if got, want := sql, `(b1.fbool = true)`; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestBooleanAccess_And(t *testing.T) {
+	a := polyFBool.Equals(true)
+	b := polyFBool.Equals(false)
+	c := a.And(b)
+	sql := SQL(c)
+	if got, want := sql, `((b1.fbool = true) AND (b1.fbool = false))`; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestBooleanAccess_Get(t *testing.T) {
+	a := polyFBool
+	values := map[string]any{
+		"fbool": true,
+	}
+	if got, want := a.Get(values), true; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestBooleanAccess_AppendScannable(t *testing.T) {
+	a := polyFBool
+	list := []any{}
+	list = a.AppendScannable(list)
+	if got, want := len(list), 1; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestBooleanAccess_FieldValueToScan(t *testing.T) {
+	p := new(poly)
+	a := polyFBool
+	field := a.FieldValueToScan(p)
+	if _, ok := field.(*bool); !ok {
+		t.Errorf("got [%T] want [*bool]", field)
+	}
+}
+
+func TestBooleanAccess_TableAlias(t *testing.T) {
+	a := polyFBool.TableAlias("p")
+	if got, want := a.SQL(), "p.fbool"; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}

access_float.go

@@ -1,6 +1,7 @@
 package pgtalk
 
 import (
+	"bytes"
 	"strings"
 )
 
@@ -27,6 +28,13 @@ func (a float64Access) Set(v float64) float64Access {
 
 func (a float64Access) Column() ColumnInfo { return a.ColumnInfo }
 
+func (a float64Access) SQL() string {
+	buf := new(bytes.Buffer)
+	w := NewWriteContext(buf)
+	a.SQLOn(w)
+	return buf.String()
+}
+
 func (a float64Access) Equals(isFloatLike any) SQLExpression {
 	return a.Compare("=", isFloatLike)
 }

access_float_test.go

@@ -1 +1,71 @@
 package pgtalk
+
+import (
+	"testing"
+)
+
+func TestNewFloat64Access(t *testing.T) {
+	info := MakeColumnInfo(polyTable, "ffloat", NotPrimary, Nullable, 1)
+	a := NewFloat64Access(info, func(dest any) any { return &dest.(*poly).FFloat })
+	if got, want := a.Column().columnName, "ffloat"; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestFloat64Access_Set(t *testing.T) {
+	a := polyFFloat.Set(1.23)
+	if got, want := a.valueToInsert, 1.23; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestFloat64Access_Equals(t *testing.T) {
+	a := polyFFloat.Equals(1.23)
+	sql := SQL(a)
+	if got, want := sql, `(p1.ffloat = 1.23)`; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestFloat64Access_Compare(t *testing.T) {
+	a := polyFFloat.Compare(">", 1.23)
+	sql := SQL(a)
+	if got, want := sql, `(p1.ffloat > 1.23)`; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestFloat64Access_FieldValueToScan(t *testing.T) {
+	p := new(poly)
+	a := polyFFloat
+	field := a.FieldValueToScan(p)
+	if _, ok := field.(*float64); !ok {
+		t.Errorf("got [%T] want [*float64]", field)
+	}
+}
+
+func TestFloat64Access_TableAlias(t *testing.T) {
+	a := polyFFloat.TableAlias("p")
+	if got, want := a.SQL(), "p.ffloat"; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestFloat64Access_AppendScannable(t *testing.T) {
+	a := polyFFloat
+	list := []any{}
+	list = a.AppendScannable(list)
+	if got, want := len(list), 1; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}
+
+func TestFloat64Access_Get(t *testing.T) {
+	a := polyFFloat
+	values := map[string]any{
+		"ffloat": 1.23,
+	}
+	if got, want := a.Get(values), 1.23; got != want {
+		t.Errorf("got [%v] want [%v]", got, want)
+	}
+}