Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit fe867be

Browse files
rickb777rickb777
committed
converted tests to rickb777/expect
1 parent bd8126b commit fe867be

File tree

17 files changed

+262
-426
lines changed

17 files changed

+262
-426
lines changed

‎constraint/constraint_test.go‎

Lines changed: 10 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ import (
99
"github.com/jackc/pgx/v5/tracelog"
1010
_ "github.com/lib/pq"
1111
_ "github.com/mattn/go-sqlite3"
12-
. "github.com/onsi/gomega"
12+
"github.com/rickb777/expect"
1313
"github.com/rickb777/sqlapi"
1414
"github.com/rickb777/sqlapi/constraint"
1515
"github.com/rickb777/sqlapi/schema"
@@ -22,21 +22,17 @@ import (
2222
var gdb sqlapi.SqlDB
2323

2424
func TestCheckConstraint(t *testing.T) {
25-
g := NewGomegaWithT(t)
26-
2725
cc0 := constraint.CheckConstraint{
2826
Expression: "role < 3",
2927
}
3028

3129
persons := vanilla.NewRecordTable("persons", gdb).WithPrefix("constraint_").WithConstraint(cc0)
3230
fkc := persons.Constraints()[0]
3331
s := fkc.ConstraintSql(quote.AnsiQuoter, persons.Name(), 0)
34-
g.Expect(s).To(Equal(`CONSTRAINT "constraint_persons_c0" CHECK (role < 3)`), s)
32+
expect.String(s).Info(s).ToBe(t, `CONSTRAINT "constraint_persons_c0" CHECK (role < 3)`)
3533
}
3634

3735
func TestForeignKeyConstraint_withParentColumn(t *testing.T) {
38-
g := NewGomegaWithT(t)
39-
4036
fkc0 := constraint.FkConstraint{
4137
ForeignKeyColumn: "addresspk",
4238
Parent: constraint.Reference{TableName: "addresses", Column: "identity"},
@@ -46,12 +42,10 @@ func TestForeignKeyConstraint_withParentColumn(t *testing.T) {
4642
persons := vanilla.NewRecordTable("persons", gdb).WithPrefix("constraint_").WithConstraint(fkc0)
4743
fkc := persons.Constraints()[0]
4844
s := fkc.ConstraintSql(quote.AnsiQuoter, persons.Name(), 0)
49-
g.Expect(s).To(Equal(`CONSTRAINT "constraint_persons_c0" foreign key ("addresspk") references "constraint_addresses" ("identity") on update restrict on delete cascade`), s)
45+
expect.String(s).Info(s).ToBe(t, `CONSTRAINT "constraint_persons_c0" foreign key ("addresspk") references "constraint_addresses" ("identity") on update restrict on delete cascade`)
5046
}
5147

5248
func TestForeignKeyConstraint_withoutParentColumn_withoutQuotes(t *testing.T) {
53-
g := NewGomegaWithT(t)
54-
5549
fkc0 := constraint.FkConstraint{
5650
ForeignKeyColumn: "addresspk",
5751
Parent: constraint.Reference{TableName: "addresses", Column: ""},
@@ -61,12 +55,10 @@ func TestForeignKeyConstraint_withoutParentColumn_withoutQuotes(t *testing.T) {
6155
persons := vanilla.NewRecordTable("persons", gdb).WithPrefix("constraint_").WithConstraint(fkc0)
6256
fkc := persons.Constraints().FkConstraints()[0]
6357
s := fkc.ConstraintSql(quote.NoQuoter, persons.Name(), 0)
64-
g.Expect(s).To(Equal(`CONSTRAINT constraint_persons_c0 foreign key (addresspk) references constraint_addresses on update restrict on delete cascade`), s)
58+
expect.String(s).Info(s).ToBe(t, `CONSTRAINT constraint_persons_c0 foreign key (addresspk) references constraint_addresses on update restrict on delete cascade`)
6559
}
6660

6761
func TestIdsUsedAsForeignKeys(t *testing.T) {
68-
g := NewGomegaWithT(t)
69-
7062
aid1, aid2, aid3, aid4 := insertFixtures(t, gdb)
7163

7264
fkc0 := constraint.FkConstraint{
@@ -81,18 +73,16 @@ func TestIdsUsedAsForeignKeys(t *testing.T) {
8173

8274
m1, err := fkc.RelationshipWith(persons.Name()).IdsUsedAsForeignKeys(persons)
8375

84-
g.Expect(err).To(BeNil())
85-
g.Expect(m1.Slice()).To(ConsistOf(aid1, aid2))
76+
expect.Error(err).ToBeNil(t)
77+
expect.Slice(m1.Slice()).ToContainAll(t, aid1, aid2)
8678

8779
m2, err := fkc.RelationshipWith(persons.Name()).IdsUnusedAsForeignKeys(persons)
8880

89-
g.Expect(err).To(BeNil())
90-
g.Expect(m2.Slice()).To(ConsistOf(aid3, aid4))
81+
expect.Error(err).ToBeNil(t)
82+
expect.Slice(m2.Slice()).ToContainAll(t, aid3, aid4)
9183
}
9284

9385
func TestFkConstraintOfField(t *testing.T) {
94-
g := NewGomegaWithT(t)
95-
9686
i64 := schema.Type{Name: "int64", Base: types.Int64}
9787
field := &schema.Field{
9888
Node: schema.Node{Name: "Cat", Type: i64},
@@ -105,15 +95,15 @@ func TestFkConstraintOfField(t *testing.T) {
10595
}
10696

10797
fkc := constraint.FkConstraintOfField(field)
108-
g.Expect(fkc).To(Equal(constraint.FkConstraint{
98+
expect.Any(fkc).ToBe(t, constraint.FkConstraint{
10999
ForeignKeyColumn: "cat",
110100
Parent: constraint.Reference{
111101
TableName: "something",
112102
Column: "pk",
113103
},
114104
Update: "restrict",
115105
Delete: "cascade",
116-
}))
106+
})
117107
}
118108

119109
//-------------------------------------------------------------------------------------------------

‎constraint/fixtures_test.go‎

Lines changed: 11 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -5,35 +5,33 @@ import (
55
"fmt"
66
"testing"
77

8-
"github.com/onsi/gomega"
8+
"github.com/rickb777/expect"
99
"github.com/rickb777/sqlapi"
1010
"github.com/rickb777/sqlapi/driver"
1111
"github.com/rickb777/where/dialect"
1212
)
1313

1414
func insertFixtures(t *testing.T, d sqlapi.Execer) (aid1, aid2, aid3, aid4 int64) {
15-
g := gomega.NewGomegaWithT(t)
16-
1715
for _, s := range createTablesSql(d.Dialect()) {
1816
_, err := d.Exec(context.Background(), s)
19-
g.Expect(err).To(gomega.BeNil())
17+
expect.Error(err).ToBeNil(t)
2018
}
2119

22-
aid1 = insertOne(g, d, address1)
23-
aid2 = insertOne(g, d, address2)
24-
aid3 = insertOne(g, d, address3)
25-
aid4 = insertOne(g, d, address4)
20+
aid1 = insertOne(t, d, address1)
21+
aid2 = insertOne(t, d, address2)
22+
aid3 = insertOne(t, d, address3)
23+
aid4 = insertOne(t, d, address4)
2624

27-
insertOne(g, d, fmt.Sprintf(person1a, aid1))
28-
insertOne(g, d, fmt.Sprintf(person1b, aid1))
29-
insertOne(g, d, fmt.Sprintf(person2a, aid2))
25+
insertOne(t, d, fmt.Sprintf(person1a, aid1))
26+
insertOne(t, d, fmt.Sprintf(person1b, aid1))
27+
insertOne(t, d, fmt.Sprintf(person2a, aid2))
3028

3129
return aid1, aid2, aid3, aid4
3230
}
3331

34-
func insertOne(g *gomega.GomegaWithT, d sqlapi.Execer, query string) int64 {
32+
func insertOne(t *testing.T, d sqlapi.Execer, query string) int64 {
3533
id, err := d.Insert(context.Background(), "id", query)
36-
g.Expect(err).To(gomega.BeNil())
34+
expect.Error(err).ToBeNil(t)
3735
return id
3836
}
3937

‎database_test.go‎

Lines changed: 33 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -15,16 +15,14 @@ import (
1515
"github.com/jackc/pgx/v5/tracelog"
1616
_ "github.com/lib/pq"
1717
_ "github.com/mattn/go-sqlite3"
18-
. "github.com/onsi/gomega"
18+
"github.com/rickb777/expect"
1919
"github.com/rickb777/sqlapi/pgxapi/logadapter"
2020
"github.com/rickb777/sqlapi/support/testenv"
2121
)
2222

2323
var gdb SqlDB
2424

2525
func TestLoggingOnOff(t *testing.T) {
26-
g := NewGomegaWithT(t)
27-
2826
ctx := context.Background()
2927
buf := &bytes.Buffer{}
3028
logger := logadapter.NewLogger(log.New(buf, "X.", 0))
@@ -38,12 +36,10 @@ func TestLoggingOnOff(t *testing.T) {
3836
tl.LogQuery(ctx, "four")
3937

4038
s := buf.String()
41-
g.Expect(s).To(Equal("X.one []\nX.two []\nX.four []\n"))
39+
expect.String(s).ToBe(t, "X.one []\nX.two []\nX.four []\n")
4240
}
4341

4442
func TestLoggingError(t *testing.T) {
45-
g := NewGomegaWithT(t)
46-
4743
ctx := context.Background()
4844
buf := &bytes.Buffer{}
4945
logger := logadapter.NewLogger(log.New(buf, "X.", 0))
@@ -58,80 +54,70 @@ func TestLoggingError(t *testing.T) {
5854
tl.LogIfError(ctx, fmt.Errorf("four"))
5955

6056
s := buf.String()
61-
g.Expect(s).To(Equal("X.Error [error:one]\nX.Error [error:three]\nX.Error [error:four]\n"))
57+
expect.String(s).ToBe(t, "X.Error [error:one]\nX.Error [error:three]\nX.Error [error:four]\n")
6258
}
6359

6460
func TestListTables(t *testing.T) {
65-
g := NewGomegaWithT(t)
66-
6761
list, err := ListTables(gdb, nil)
68-
g.Expect(err).NotTo(HaveOccurred())
69-
g.Expect(slices.DeleteFunc(list, func(s string) bool {
62+
expect.Error(err).Not().ToHaveOccurred(t)
63+
expect.Slice(slices.DeleteFunc(list, func(s string) bool {
7064
return !strings.HasPrefix(s, "sql_")
71-
})).To(HaveLen(0))
72-
g.Expect(slices.DeleteFunc(list, func(s string) bool {
65+
})).ToHaveLength(t, 0)
66+
expect.Slice(slices.DeleteFunc(list, func(s string) bool {
7367
return !strings.HasPrefix(s, "pg_")
74-
})).To(HaveLen(0))
68+
})).ToHaveLength(t, 0)
7569
}
7670

7771
func TestQueryRowContext(t *testing.T) {
78-
g := NewGomegaWithT(t)
79-
8072
_, aid2, _, _ := insertFixtures(t, gdb)
8173

8274
q := gdb.Dialect().ReplacePlaceholders("select xlines from pfx_addresses where id=?", nil)
8375
row := gdb.QueryRow(context.Background(), q, aid2)
8476

8577
var xlines string
8678
err := row.Scan(&xlines)
87-
g.Expect(err).NotTo(HaveOccurred())
88-
g.Expect(xlines).To(Equal("2 Nutmeg Lane"))
79+
expect.Error(err).Not().ToHaveOccurred(t)
80+
expect.String(xlines).ToBe(t, "2 Nutmeg Lane")
8981
}
9082

9183
func TestQueryContext(t *testing.T) {
92-
g := NewGomegaWithT(t)
93-
9484
_, aid2, _, _ := insertFixtures(t, gdb)
9585

9686
q := gdb.Dialect().ReplacePlaceholders("select xlines from pfx_addresses where id=?", nil)
9787
rows, err := gdb.Query(context.Background(), q, aid2)
98-
g.Expect(err).NotTo(HaveOccurred())
99-
g.Expect(rows.Next()).To(BeTrue())
88+
expect.Error(err).Not().ToHaveOccurred(t)
89+
expect.Bool(rows.Next()).ToBeTrue(t)
10090

10191
var xlines string
10292
err = rows.Scan(&xlines)
103-
g.Expect(err).NotTo(HaveOccurred())
104-
g.Expect(xlines).To(Equal("2 Nutmeg Lane"))
93+
expect.Error(err).Not().ToHaveOccurred(t)
94+
expect.String(xlines).ToBe(t, "2 Nutmeg Lane")
10595

106-
g.Expect(rows.Next()).NotTo(BeTrue())
96+
expect.Bool(rows.Next()).Not().ToBeTrue(t)
10797
}
10898

10999
func TestSingleConnQuery(t *testing.T) {
110-
g := NewGomegaWithT(t)
111-
112100
ctx := context.Background()
113101
_, aid2, _, _ := insertFixtures(t, gdb)
114102

115103
q := gdb.Dialect().ReplacePlaceholders("select xlines from pfx_addresses where id=?", nil)
116104
e2 := gdb.SingleConn(ctx, func(ex Execer) error {
117105
rows, err := ex.Query(ctx, q, aid2)
118-
g.Expect(err).NotTo(HaveOccurred())
119-
g.Expect(rows.Next()).To(BeTrue())
106+
expect.Error(err).Not().ToHaveOccurred(t)
107+
expect.Bool(rows.Next()).ToBeTrue(t)
120108

121109
var xlines string
122110
err = rows.Scan(&xlines)
123-
g.Expect(err).NotTo(HaveOccurred())
124-
g.Expect(xlines).To(Equal("2 Nutmeg Lane"))
111+
expect.Error(err).Not().ToHaveOccurred(t)
112+
expect.String(xlines).ToBe(t, "2 Nutmeg Lane")
125113

126-
g.Expect(rows.Next()).NotTo(BeTrue())
114+
expect.Bool(rows.Next()).Not().ToBeTrue(t)
127115
return err
128116
})
129-
g.Expect(e2).NotTo(HaveOccurred())
117+
expect.Error(e2).Not().ToHaveOccurred(t)
130118
}
131119

132120
func TestTransactCommitUsingInsert(t *testing.T) {
133-
g := NewGomegaWithT(t)
134-
135121
ctx := context.Background()
136122
insertFixtures(t, gdb)
137123

@@ -145,19 +131,17 @@ func TestTransactCommitUsingInsert(t *testing.T) {
145131
}
146132
return nil
147133
})
148-
g.Expect(err).NotTo(HaveOccurred())
134+
expect.Error(err).Not().ToHaveOccurred(t)
149135

150136
row := gdb.QueryRow(ctx, "select count(1) from pfx_addresses")
151137

152138
var count int
153139
err = row.Scan(&count)
154-
g.Expect(err).NotTo(HaveOccurred())
155-
g.Expect(count).To(Equal(14))
140+
expect.Error(err).Not().ToHaveOccurred(t)
141+
expect.Number(count).ToBe(t, 14)
156142
}
157143

158144
func TestTransactCommitUsingExec(t *testing.T) {
159-
g := NewGomegaWithT(t)
160-
161145
ctx := context.Background()
162146
_, aid2, aid3, _ := insertFixtures(t, gdb)
163147

@@ -166,19 +150,17 @@ func TestTransactCommitUsingExec(t *testing.T) {
166150
_, e2 := tx.Exec(ctx, q, aid2, aid3)
167151
return e2
168152
})
169-
g.Expect(err).NotTo(HaveOccurred())
153+
expect.Error(err).Not().ToHaveOccurred(t)
170154

171155
row := gdb.QueryRow(ctx, "select count(1) from pfx_addresses")
172156

173157
var count int
174158
err = row.Scan(&count)
175-
g.Expect(err).NotTo(HaveOccurred())
176-
g.Expect(count).To(Equal(2))
159+
expect.Error(err).Not().ToHaveOccurred(t)
160+
expect.Number(count).ToBe(t, 2)
177161
}
178162

179163
func TestTransactRollback(t *testing.T) {
180-
g := NewGomegaWithT(t)
181-
182164
ctx := context.Background()
183165
_, aid2, aid3, _ := insertFixtures(t, gdb)
184166

@@ -187,23 +169,21 @@ func TestTransactRollback(t *testing.T) {
187169
tx.Exec(ctx, q, aid2, aid3)
188170
return errors.New("Bang")
189171
})
190-
g.Expect(err).To(HaveOccurred())
191-
g.Expect(err.Error()).To(Equal("Bang"))
172+
expect.Error(err).ToHaveOccurred(t)
173+
expect.Error(err).ToContain(t, "Bang")
192174

193175
row := gdb.QueryRow(ctx, "select count(1) from pfx_addresses")
194176

195177
var count int
196178
err = row.Scan(&count)
197-
g.Expect(err).NotTo(HaveOccurred())
198-
g.Expect(count).To(Equal(4))
179+
expect.Error(err).Not().ToHaveOccurred(t)
180+
expect.Number(count).ToBe(t, 4)
199181
}
200182

201183
func TestUserItemWrapper(t *testing.T) {
202-
g := NewGomegaWithT(t)
203-
204184
d2 := gdb.With("hello")
205-
g.Expect(gdb.UserItem()).To(BeNil())
206-
g.Expect(d2.UserItem().(string)).To(Equal("hello"))
185+
expect.Any(gdb.UserItem()).ToBeNil(t)
186+
expect.String(d2.UserItem().(string)).ToBe(t, "hello")
207187
}
208188

209189
//-------------------------------------------------------------------------------------------------

0 commit comments

Comments
 (0)