removed support for exclusion constraint, more tests

Author: piotrkowalczuk

constraint.go

@@ -31,7 +31,6 @@ type ConstraintOption func(*Constraint)
 type Constraint struct {
 	Type                                                                 ConstraintType
 	Where, Check                                                         string
-	Exclude                                                              Exclude
 	Table, ReferenceTable                                                *Table
 	Columns, ReferenceColumns                                            Columns
 	Attribute                                                            []*Attribute
@@ -95,29 +94,18 @@ func Check(table *Table, check string, columns ...*Column) *Constraint {
 	}
 }
 
-// Exclusion constraint ensure that if any two rows are compared on the specified columns
-// or expressions using the specified operators,
-// at least one of these operator comparisons will return false or null.
-func Exclusion(table *Table, exclude Exclude, columns ...*Column) *Constraint {
-	return &Constraint{
-		Type:    ConstraintTypeExclusion,
-		Table:   table,
-		Exclude: exclude,
-		Columns: columns,
-	}
-}
-
-// Exclude ...
-type Exclude struct {
-	Using    string
-	Elements []Elements
-}
-
-// Elements ...
-type Elements struct {
-	Selector string
-	Operator string
-}
+//
+//// Exclusion constraint ensure that if any two rows are compared on the specified columns
+//// or expressions using the specified operators,
+//// at least one of these operator comparisons will return false or null.
+//func Exclusion(table *Table, exclude Exclude, columns ...*Column) *Constraint {
+//	return &Constraint{
+//		Type:    ConstraintTypeExclusion,
+//		Table:   table,
+//		Exclude: exclude,
+//		Columns: columns,
+//	}
+//}
 
 // Reference ...
 type Reference struct {
@@ -190,10 +178,10 @@ func IsCheck(c string) bool {
 	return strings.HasSuffix(c, string(ConstraintTypeCheck))
 }
 
-// IsExclusion returns true if string has suffix "_excl".
-func IsExclusion(c string) bool {
-	return strings.HasSuffix(c, string(ConstraintTypeExclusion))
-}
+//// IsExclusion returns true if string has suffix "_excl".
+//func IsExclusion(c string) bool {
+//	return strings.HasSuffix(c, string(ConstraintTypeExclusion))
+//}
 
 // IsIndex returns true if string has suffix "_idx".
 func IsIndex(c string) bool {

constraint_test.go

@@ -8,25 +8,6 @@ import (
 	"github.com/piotrkowalczuk/pqt"
 )
 
-func TestExclusion(t *testing.T) {
-	col1 := pqt.NewColumn("a", pqt.TypeIntegerBig())
-	col2 := pqt.NewColumn("b", pqt.TypeIntegerBig())
-	tbl := pqt.NewTable("table").AddColumn(col1).AddColumn(col2)
-	got := pqt.Exclusion(tbl, pqt.Exclude{
-		Using: "gist",
-		Elements: []pqt.Elements{
-			{
-				Operator: "=",
-				Selector: "a",
-			},
-		},
-	}, col1, col2)
-
-	if len(got.Exclude.Elements) != 1 {
-		t.Error("expected one exclude element")
-	}
-}
-
 func TestConstraint_Name(t *testing.T) {
 	id := pqt.NewColumn("id", pqt.TypeSerial(), pqt.WithPrimaryKey())
 	success := map[string]*pqt.Constraint{

example/app/internal/model/main_test.go

@@ -109,7 +109,7 @@ func populateNews(t testing.TB, r *model.NewsRepositoryBase, nb int) {
 			Content:  fmt.Sprintf("content-%d", i),
 			Lead:     sql.NullString{String: fmt.Sprintf("lead-%d", i), Valid: true},
 			Continue: true,
-			Score: 10.11,
+			Score:    10.11,
 		})
 		if err != nil {
 			t.Fatalf("unexpected error #%d: %s", i, err.Error())

table_test.go

@@ -203,88 +203,37 @@ func TestTable_AddRelationship_oneToMany(t *testing.T) {
 	}
 }
 
-//func TestTable_AddRelationship_manyToMany(t *testing.T) {
-//	user := pqt.NewTable("user").AddColumn(pqt.NewColumn("id", pqt.TypeSerial(), pqt.WithPrimaryKey()))
-//	group := pqt.NewTable("group").AddColumn(pqt.NewColumn("id", pqt.TypeSerial(), pqt.WithPrimaryKey()))
-//	userGroups := pqt.NewTable("user_groups")
-//	user.AddRelationship(pqt.ManyToMany(
-//		group,
-//		userGroups,
-//		pqt.WithInversedName("users"),
-//		pqt.WithOwnerName("groups"),
-//	))
-//
-//	if len(user.Relationships) != 1 {
-//		t.Fatalf("user should have 1 relationship, but has %d", len(user.Relationships))
-//	}
-//
-//	if user.Relationships[0].OwnerName != "groups" {
-//		t.Errorf("user relationship to group should be mapped by groups")
-//	}
-//
-//	if user.Relationships[0].OwnerTable != group {
-//		t.Errorf("user relationship to group should be mapped by group table")
-//	}
-//
-//	if user.Relationships[0].Type != pqt.RelationshipTypeManyToMany {
-//		t.Errorf("user relationship to group should be many to many")
-//	}
-//
-//	if len(group.Relationships) != 1 {
-//		t.Fatalf("group should have 1 relationship, but has %d", len(group.Relationships))
-//	}
-//
-//	if group.Relationships[0].InversedName != "users" {
-//		t.Errorf("group relationship to user should be mapped by users")
-//	}
-//
-//	if group.Relationships[0].InversedTable != user {
-//		t.Errorf("group relationship to user should be mapped by user table")
-//	}
-//
-//	if group.Relationships[0].Type != pqt.RelationshipTypeManyToMany {
-//		t.Errorf("group relationship to user should be %d, but is %d", pqt.RelationshipTypeManyToMany, group.Relationships[0].Type)
-//	}
-//}
-//
-//func TestTable_AddRelationship_manyToManySelfReferencing(t *testing.T) {
-//	friendship := pqt.NewTable("friendship")
-//	user := pqt.NewTable("user").
-//		AddColumn(pqt.NewColumn("id", pqt.TypeSerial(), pqt.WithPrimaryKey())).
-//		AddRelationship(pqt.ManyToManySelfReferencing(
-//		friendship,
-//		pqt.WithInversedName("friends_with_me"),
-//		pqt.WithOwnerName("my_friends"),
-//	))
-//
-//	if len(user.Relationships) != 2 {
-//		t.Fatalf("user should have 2 relationships, but has %d", len(user.Relationships))
-//	}
-//
-//	if user.Relationships[0].OwnerName != "my_friends" {
-//		t.Errorf("user relationship to user should be mapped by my_friends")
-//	}
-//
-//	if user.Relationships[0].OwnerTable != user {
-//		t.Errorf("user relationship to group should be mapped by group table")
-//	}
-//
-//	if user.Relationships[0].Type != pqt.RelationshipTypeManyToManySelfReferencing {
-//		t.Errorf("user relationship to group should be many to many")
-//	}
-//
-//	if user.Relationships[1].InversedName != "friends_with_me" {
-//		t.Errorf("user relationship to user should be mapped by friends_with_me")
-//	}
-//
-//	if user.Relationships[1].InversedTable != user {
-//		t.Errorf("user relationship to user should be mapped by user table")
-//	}
-//
-//	if user.Relationships[1].Type != pqt.RelationshipTypeManyToManySelfReferencing {
-//		t.Errorf("user relationship to user should be %d, but is %d", pqt.RelationshipTypeManyToManySelfReferencing, user.Relationships[1].Type)
-//	}
-//}
+func TestTable_AddRelationship_manyToMany(t *testing.T) {
+	user := pqt.NewTable("user").AddColumn(pqt.NewColumn("id", pqt.TypeSerial(), pqt.WithPrimaryKey()))
+	group := pqt.NewTable("group").AddColumn(pqt.NewColumn("id", pqt.TypeSerial(), pqt.WithPrimaryKey()))
+	userGroups := pqt.NewTable("user_groups")
+	user.AddRelationship(pqt.ManyToMany(
+		group,
+		userGroups,
+		pqt.WithInversedName("users"),
+		pqt.WithOwnerName("groups"),
+	))
+
+	if len(user.OwnedRelationships) != 1 {
+		t.Fatalf("user should have 1 relationship, but has %d", len(user.OwnedRelationships))
+	}
+
+	if user.OwnedRelationships[0].OwnerName != "groups" {
+		t.Errorf("user relationship to group should be mapped by groups")
+	}
+
+	if user.OwnedRelationships[0].OwnerTable != group {
+		t.Errorf("user relationship to group should be mapped by group table")
+	}
+
+	if user.OwnedRelationships[0].Type != pqt.RelationshipTypeManyToMany {
+		t.Errorf("user relationship to group should be many to many")
+	}
+
+	if len(group.InversedRelationships) != 0 {
+		t.Fatalf("group should have 0 relationship, but has %d", len(group.InversedRelationships))
+	}
+}
 
 func TestTable_FullName(t *testing.T) {
 	tbl := pqt.NewTable("table")

type_test.go

@@ -3,9 +3,48 @@ package pqt_test
 import (
 	"testing"
 
+	"reflect"
+
 	"github.com/piotrkowalczuk/pqt"
 )
 
+func TestTypeSerialSmall(t *testing.T) {
+	assertType(t, "SMALLSERIAL", pqt.TypeSerialSmall())
+}
+
+func TestTypeSerialBig(t *testing.T) {
+	assertType(t, "BIGSERIAL", pqt.TypeSerialBig())
+}
+
+func TestTypeUUID(t *testing.T) {
+	assertType(t, "UUID", pqt.TypeUUID())
+}
+
+func TestTypeCharacter(t *testing.T) {
+	assertType(t, "CHARACTER[100]", pqt.TypeCharacter(100))
+}
+
+func TestTypeBytea(t *testing.T) {
+	assertType(t, "BYTEA", pqt.TypeBytea())
+}
+
+func TestTypeTimestamp(t *testing.T) {
+	assertType(t, "TIMESTAMP", pqt.TypeTimestamp())
+}
+func TestTypeTimestampTZ(t *testing.T) {
+	assertType(t, "TIMESTAMPTZ", pqt.TypeTimestampTZ())
+}
+func TestTypeJSON(t *testing.T) {
+	assertType(t, "JSON", pqt.TypeJSON())
+}
+func TestTypeJSONB(t *testing.T) {
+	assertType(t, "JSONB", pqt.TypeJSONB())
+}
+
+func TestTypeIntegerSmall(t *testing.T) {
+	assertType(t, "SMALLINT", pqt.TypeIntegerSmall())
+}
+
 func TestTypeIntegerSmallArray_zero(t *testing.T) {
 	expected := "SMALLINT[]"
 	got := pqt.TypeIntegerSmallArray(0)
@@ -104,8 +143,61 @@ func TestTypeDoubleArray(t *testing.T) {
 	assertType(t, expected, got)
 }
 
+func TestTypeReal(t *testing.T) {
+	expected := "REAL"
+	got := pqt.TypeReal()
+	assertType(t, expected, got)
+}
+
+func TestTypeDoublePrecision(t *testing.T) {
+	expected := "DOUBLE PRECISION"
+	got := pqt.TypeDoublePrecision()
+	assertType(t, expected, got)
+}
+
+func TestTypeTextArray_zero(t *testing.T) {
+	expected := "TEXT[]"
+	got := pqt.TypeTextArray(0)
+	assertType(t, expected, got)
+}
+
+func TestTypeTextArray(t *testing.T) {
+	expected := "TEXT[100]"
+	got := pqt.TypeTextArray(100)
+	assertType(t, expected, got)
+}
+
+func TestTypeVarchar_zero(t *testing.T) {
+	expected := "VARCHAR"
+	got := pqt.TypeVarchar(0)
+	assertType(t, expected, got)
+}
+
+func TestTypeVarchar(t *testing.T) {
+	expected := "VARCHAR(100)"
+	got := pqt.TypeVarchar(100)
+	assertType(t, expected, got)
+}
+
 func assertType(t *testing.T, expected string, got pqt.Type) {
 	if got.String() != expected {
 		t.Errorf("unexpected sql representation, expected %s got %s", expected, got.String())
 	}
 }
+
+func TestBaseType_Fingerprint(t *testing.T) {
+	if pqt.TypeText().Fingerprint() != "base: TEXT" {
+		t.Errorf("wrong fingerprint: %s", pqt.TypeText().Fingerprint())
+	}
+}
+
+func TestTypeEnumerated(t *testing.T) {
+	given := pqt.TypeEnumerated("pets", "cat", "dog", "pig")
+	assertType(t, "pets", given)
+	if !reflect.DeepEqual(given.Enums, []string{"cat", "dog", "pig"}) {
+		t.Errorf("wrong set of enums: %v", given.Enums)
+	}
+	if given.Fingerprint() != "enumarated: pets" {
+		t.Errorf("wrong fingerprint: %s", given.Fingerprint())
+	}
+}