pqtgo.TypeMapOfStrings removed, more tests

Author: piotrkowalczuk

example/app/internal/model/main_test.go

@@ -9,7 +9,9 @@ import (
 	"strconv"
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/lib/pq"
 	"github.com/piotrkowalczuk/pqt/example/app/internal/model"
 )
 
@@ -116,3 +118,29 @@ func populateNews(t testing.TB, r *model.NewsRepositoryBase, nb int) {
 		}
 	}
 }
+
+func populateCategory(t testing.TB, r *model.CategoryRepositoryBase, nb int) {
+	for i := 1; i <= nb; i++ {
+		_, err := r.Insert(context.Background(), &model.CategoryEntity{
+			Name:      fmt.Sprintf("name-%d", i),
+			Content:   fmt.Sprintf("content-%d", i),
+			CreatedAt: time.Now(),
+		})
+		if err != nil {
+			t.Fatalf("unexpected error #%d: %s", i, err.Error())
+		}
+
+		for j := 1; j <= nb; j++ {
+			_, err := r.Insert(context.Background(), &model.CategoryEntity{
+				ParentID:  sql.NullInt64{Int64: int64(i), Valid: true},
+				Name:      fmt.Sprintf("name-%d-%d", i, j),
+				Content:   fmt.Sprintf("content-%d-%d", i, j),
+				CreatedAt: time.Now(),
+				UpdatedAt: pq.NullTime{Time: time.Now(), Valid: true},
+			})
+			if err != nil {
+				t.Fatalf("unexpected error #%d: %s", i, err.Error())
+			}
+		}
+	}
+}

example/app/internal/model/schema_category_test.go

@@ -0,0 +1,148 @@
+package model_test
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"database/sql"
+
+	"github.com/lib/pq"
+	"github.com/piotrkowalczuk/pqt/example/app/internal/model"
+)
+
+func TestCategoryRepositoryBase_FindIter(t *testing.T) {
+	s := setup(t)
+	defer s.teardown(t)
+
+	max := 10
+	populateCategory(t, s.category, max)
+	iter, err := s.category.FindIter(context.Background(), &model.CategoryFindExpr{})
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err.Error())
+	}
+	defer iter.Close()
+
+	var got []*model.CategoryEntity
+	for iter.Next() {
+		ent, err := iter.Category()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err.Error())
+		}
+		got = append(got, ent)
+	}
+	if err = iter.Err(); err != nil {
+		t.Fatalf("unexpected error: %s", err.Error())
+	}
+	exp := (max * max) + max
+	if len(got) != exp {
+		t.Errorf("wrong output, expected %d but got %d", exp, len(got))
+	}
+}
+
+func TestCategoryRepositoryBase_Count(t *testing.T) {
+	s := setup(t)
+	defer s.teardown(t)
+
+	max := 10
+	populateCategory(t, s.category, max)
+	got, err := s.category.Count(context.Background(), &model.CategoryCountExpr{
+		Where: &model.CategoryCriteria{
+			Content:  sql.NullString{String: "content-5-1", Valid: true},
+			Name:     sql.NullString{String: "name-5-1", Valid: true},
+			ParentID: sql.NullInt64{Int64: 5, Valid: true},
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err.Error())
+	}
+
+	if got != 1 {
+		t.Errorf("wrong output, expected %d but got %d", 1, got)
+	}
+}
+
+func TestCategoryRepositoryBase_Find(t *testing.T) {
+	s := setup(t)
+	defer s.teardown(t)
+
+	max := 10
+	populateCategory(t, s.category, max)
+	got, err := s.category.Find(context.Background(), &model.CategoryFindExpr{
+		Where: &model.CategoryCriteria{
+			Content:  sql.NullString{String: "content-5-1", Valid: true},
+			Name:     sql.NullString{String: "name-5-1", Valid: true},
+			ParentID: sql.NullInt64{Int64: 5, Valid: true},
+		},
+		Limit:  10,
+		Offset: 0,
+		OrderBy: map[string]bool{
+			model.TableCategoryColumnID: true,
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err.Error())
+	}
+
+	if len(got) != 1 {
+		t.Errorf("wrong output, expected %d but got %d", 1, len(got))
+	}
+}
+
+func TestCategoryRepositoryBase_FindOneByID(t *testing.T) {
+	s := setup(t)
+	defer s.teardown(t)
+
+	expected := 5
+	populateCategory(t, s.category, expected)
+
+	for i := 1; i <= expected; i++ {
+		got, err := s.category.FindOneByID(context.Background(), int64(i))
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err.Error())
+		}
+		if got.ID != int64(i) {
+			t.Errorf("wrong id, expected %d but got %d", i, got.ID)
+		}
+	}
+}
+
+func TestCategoryRepositoryBase_UpdateOneByID(t *testing.T) {
+	s := setup(t)
+	defer s.teardown(t)
+
+	expected := 10
+	populateCategory(t, s.category, expected)
+
+	for i := 1; i <= expected; i++ {
+		got, err := s.category.UpdateOneByID(context.Background(), int64(i), &model.CategoryPatch{
+			Content: sql.NullString{
+				Valid:  true,
+				String: fmt.Sprintf("content-updated-by-id-%d", i),
+			},
+			Name: sql.NullString{
+				Valid:  true,
+				String: fmt.Sprintf("name-updated-by-id-%d", i),
+			},
+			CreatedAt: pq.NullTime{
+				Valid: true,
+				Time:  time.Now(),
+			},
+			UpdatedAt: pq.NullTime{
+				Valid: true,
+				Time:  time.Now(),
+			},
+		})
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err.Error())
+		}
+		if got.ID != int64(i) {
+			t.Errorf("wrong id, expected %d but got %d", i, got.ID)
+		}
+		if !strings.HasPrefix(got.Content, "content-updated-by-id") {
+			t.Error("content was not updated properly")
+		}
+	}
+}

pqtgo/type.go

@@ -120,12 +120,3 @@ func (ct CustomType) TypeOf(m int32) reflect.Type {
 		return nil
 	}
 }
-
-// TypeMapOfStrings ....
-func TypeMapOfStrings() CustomType {
-	return TypeCustom(
-		map[string]string{},
-		map[string]string{},
-		nil,
-	)
-}

pqtgo/type_test.go

@@ -0,0 +1,107 @@
+package pqtgo_test
+
+import (
+	"go/types"
+	"testing"
+
+	"reflect"
+
+	"github.com/piotrkowalczuk/pqt/pqtgo"
+)
+
+func TestBuiltinType_String(t *testing.T) {
+	cases := map[string]types.BasicKind{
+		"invalid":    types.Invalid,
+		"bool":       types.Bool,
+		"int":        types.Int,
+		"int8":       types.Int8,
+		"int16":      types.Int16,
+		"int32":      types.Int32,
+		"int64":      types.Int64,
+		"uint":       types.Uint,
+		"uint8":      types.Uint8,
+		"uint16":     types.Uint16,
+		"uint32":     types.Uint32,
+		"uint64":     types.Uint64,
+		"float32":    types.Float32,
+		"float64":    types.Float64,
+		"complex64":  types.Complex64,
+		"complex128": types.Complex128,
+		"string":     types.String,
+	}
+	for exp, kind := range cases {
+		t.Run(exp, func(t *testing.T) {
+			got := pqtgo.BuiltinType(kind).String()
+			if got != exp {
+				t.Errorf("wrong string representation of go builtin type: %s", got)
+			}
+			got = pqtgo.BuiltinType(kind).Fingerprint()
+			if got != "gobuiltin: "+exp {
+				t.Errorf("wrong fingerprint of go builtin type: %s", got)
+			}
+		})
+	}
+}
+
+func TestTypeCustom(t *testing.T) {
+	type mandatory struct {
+		X string
+	}
+	type optional struct {
+		X string
+	}
+	type criteria struct {
+		X string
+	}
+
+	m := &mandatory{}
+	o := &optional{}
+	c := &criteria{}
+
+	got := pqtgo.TypeCustom(m, o, c)
+	valueOfM := got.ValueOf(pqtgo.ModeMandatory)
+	valueOfO := got.ValueOf(pqtgo.ModeOptional)
+	valueOfC := got.ValueOf(pqtgo.ModeCriteria)
+	valueOfD := got.ValueOf(pqtgo.ModeDefault)
+
+	if valueOfD != nil {
+		t.Error("value of default should be nil")
+	}
+	if !reflect.DeepEqual(m, valueOfM) {
+		t.Errorf("wrong mandatory value found: %v", valueOfM)
+	}
+	if !reflect.DeepEqual(o, valueOfO) {
+		t.Errorf("wrong optional value found: %v", valueOfO)
+	}
+	if !reflect.DeepEqual(c, valueOfC) {
+		t.Errorf("wrong criteria value found: %v", valueOfC)
+	}
+
+	typeOfM := got.TypeOf(pqtgo.ModeMandatory)
+	typeOfO := got.TypeOf(pqtgo.ModeOptional)
+	typeOfC := got.TypeOf(pqtgo.ModeCriteria)
+	typeOfD := got.TypeOf(pqtgo.ModeDefault)
+
+	if typeOfD != nil {
+		t.Error("type of default should be nil")
+	}
+	if typeOfM.String() != "*pqtgo_test.mandatory" {
+		t.Errorf("wrong mandatory type found: %s", typeOfM.String())
+	}
+	if typeOfO.String() != "*pqtgo_test.optional" {
+		t.Errorf("wrong optional type found: %s", typeOfO.String())
+	}
+	if typeOfC.String() != "*pqtgo_test.criteria" {
+		t.Errorf("wrong criteria type found: %s", typeOfC.String())
+	}
+
+	gotS := got.String()
+	if gotS != "*pqtgo_test.mandatory/*pqtgo_test.optional/*pqtgo_test.criteria" {
+		t.Errorf("wrong string representation: %s", got.String())
+	}
+
+	gotF := got.Fingerprint()
+	if gotF != "gocustomtype: *pqtgo_test.mandatory/*pqtgo_test.optional/*pqtgo_test.criteria" {
+		t.Errorf("wrong fingerprint: %s", got.Fingerprint())
+	}
+}

relationship.go

@@ -97,7 +97,7 @@ func WithOwnerForeignKey(columns, references Columns, opts ...ConstraintOption)
 	return func(r *Relationship) {
 		for _, c := range columns {
 			if r.OwnerTable != c.Table {
-				panic("colum tables inconsistency")
+				panic("table columns inconsistency")
 			}
 		}
 		r.OwnerForeignKey = ForeignKey(columns, references, opts...)

schema_test.go

@@ -0,0 +1,31 @@
+package pqt_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/piotrkowalczuk/pqt"
+)
+
+func TestWithSchemaIfNotExists(t *testing.T) {
+	sch := pqt.NewSchema("schema", pqt.WithSchemaIfNotExists())
+	if !sch.IfNotExists {
+		t.Error("expected if not exists to be true")
+	}
+}
+
+func TestSchema_AddTable(t *testing.T) {
+	tbl := pqt.NewTable("table")
+	sch := pqt.NewSchema("schema").AddTable(tbl).AddTable(tbl)
+	if !reflect.DeepEqual(sch, tbl.Schema) {
+		t.Error("wrong schema assigned to the table")
+	}
+}
+
+func TestSchema_AddFunction(t *testing.T) {
+	fnc := pqt.FunctionNow()
+	tbl := pqt.NewSchema("schema").AddFunction(fnc)
+	if len(tbl.Functions) != 1 {
+		t.Errorf("wrong number of functions: %d", len(tbl.Functions))
+	}
+}