Skip to content

test: add more tests #9

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
chenquan merged 1 commit into from
Sep 13, 2022
Merged

test: add more tests #9

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,9 +9,9 @@ go get -u github.com/chenquan/sqlplus
```

# usage

Implement the `sqlplus.Hook` interface and wrap it with `sqlplus.New(d driver.Driver, hook Hook) driver.Driver`

# example

- [sqltrace](https://github.com/chenquan/sqltrace): A sql link tracking library,
suitable for any relational database such as MySQL, oracle, SQL Server, PostgreSQL,TiDB etc.
- [sqltrace](https://github.com/chenquan/sqltrace): A sql tracing library, suitable for any relational database such as Sqlite3, MySQL, Oracle, SQL Server, PostgreSQL, TiDB, etc.
15 changes: 8 additions & 7 deletions conn_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,7 @@ var _ driver.Conn = (*mockConn)(nil)
type mockConn struct {
}

func (c *mockConn) Prepare(query string) (driver.Stmt, error) {
func (c *mockConn) Prepare(_ string) (driver.Stmt, error) {
return &mockStmt{}, nil
}

Expand All @@ -33,7 +33,7 @@ type mockConnQueryer struct {
driver.Conn
}

func (m *mockConnQueryer) Query(query string, args []driver.Value) (driver.Rows, error) {
func (m *mockConnQueryer) Query(_ string, _ []driver.Value) (driver.Rows, error) {
return nil, nil
}

Expand All @@ -45,7 +45,7 @@ type mockConnQueryerContext struct {
driver.Conn
}

func (m *mockConnExecer) Exec(query string, args []driver.Value) (driver.Result, error) {
func (m *mockConnExecer) Exec(_ string, _ []driver.Value) (driver.Result, error) {
return nil, nil
}

Expand All @@ -57,7 +57,7 @@ type mockConnExecer struct {
driver.Conn
}

func (m *mockConnQueryerContext) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
func (m *mockConnQueryerContext) QueryContext(_ context.Context, _ string, _ []driver.NamedValue) (driver.Rows, error) {
return nil, nil
}

Expand All @@ -68,7 +68,7 @@ type mockConnExecerContext struct {
driver.Conn
}

func (m *mockConnExecerContext) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
func (m *mockConnExecerContext) ExecContext(_ context.Context, _ string, _ []driver.NamedValue) (driver.Result, error) {
return nil, nil
}

Expand All @@ -79,17 +79,18 @@ type mockConnBeginTx struct {
driver.Conn
}

func (m *mockConnBeginTx) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
func (m *mockConnBeginTx) BeginTx(_ context.Context, _ driver.TxOptions) (driver.Tx, error) {
return &mockTx{}, nil
}

// -----------------

func createMockConn() (*conn, *mockHook) {
m := &mockHook{}
hooks := NewMultiHook(m)
c := &conn{
Conn: &mockConn{},
ConnHook: m,
ConnHook: hooks,
}
return c, m
}
Expand Down
2 changes: 1 addition & 1 deletion connector.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,5 +30,5 @@ func (c *connector) Connect(ctx context.Context) (dc driver.Conn, err error) {
}

func (c *connector) Driver() driver.Driver {
return &Driver{Driver: c.Connector.Driver(), Hook: c.ConnectorHook.(Hook)}
return &wrappedDriver{Driver: c.Connector.Driver(), Hook: c.ConnectorHook.(Hook)}
}
18 changes: 18 additions & 0 deletions connector_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,18 @@
package sqlplus

import (
"context"
"database/sql/driver"
)

var _ driver.Connector = (*mockConnector)(nil)

type mockConnector struct{}

func (m *mockConnector) Connect(_ context.Context) (driver.Conn, error) {
return &mockConn{}, nil
}

func (m *mockConnector) Driver() driver.Driver {
return &mockDriver{}
}
16 changes: 8 additions & 8 deletions driver.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,29 +5,29 @@ import (
)

var (
_ driver.Driver = (*Driver)(nil)
_ driver.DriverContext = (*DriverCtx)(nil)
_ driver.Driver = (*wrappedDriver)(nil)
_ driver.DriverContext = (*wrappedDriverCtx)(nil)
)

type DriverCtx struct {
type wrappedDriverCtx struct {
driver.Driver
Hook
}

type Driver struct {
type wrappedDriver struct {
driver.Driver
Hook
}

func New(d driver.Driver, hook Hook) driver.Driver {
if _, ok := d.(driver.DriverContext); ok {
return &DriverCtx{Driver: d, Hook: hook}
return &wrappedDriverCtx{Driver: d, Hook: hook}
}

return &Driver{Driver: d, Hook: hook}
return &wrappedDriver{Driver: d, Hook: hook}
}

func (d Driver) Open(name string) (driver.Conn, error) {
func (d *wrappedDriver) Open(name string) (driver.Conn, error) {
c, err := d.Driver.Open(name)
if err != nil {
return nil, err
Expand All @@ -38,7 +38,7 @@ func (d Driver) Open(name string) (driver.Conn, error) {

// -----------------

func (d DriverCtx) OpenConnector(name string) (driver.Connector, error) {
func (d *wrappedDriverCtx) OpenConnector(name string) (driver.Connector, error) {
if dd, ok := d.Driver.(driver.DriverContext); ok {
openConnector, err := dd.OpenConnector(name)
if err != nil {
Expand Down
44 changes: 38 additions & 6 deletions driver_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,24 +1,56 @@
package sqlplus

import (
"context"
"database/sql/driver"
"testing"

"github.com/stretchr/testify/assert"
)

var _ driver.Driver = (*mockDriver)(nil)
var _ driver.DriverContext = (*mockDriverCtx)(nil)
var _ driver.Driver = (*mockDriverCtx)(nil)

type mockDriver struct {
type (
mockDriver struct{}
mockDriverCtx struct{}
)

func (d *mockDriver) Open(_ string) (driver.Conn, error) {
return &mockConn{}, nil
}

func (d *mockDriver) Open(name string) (driver.Conn, error) {
// -----------------

func (m *mockDriverCtx) OpenConnector(_ string) (driver.Connector, error) {
return &mockConnector{}, nil
}

func (m *mockDriverCtx) Open(_ string) (driver.Conn, error) {
return &mockConn{}, nil
}

func TestNew(t *testing.T) {
d := New(&mockDriver{}, &mockHook{})
conn, err := d.Open("any")
assert.NoError(t, err)
assert.NotNil(t, conn)
t.Run("mockDriver", func(t *testing.T) {
d := New(&mockDriver{}, &mockHook{})
conn, err := d.Open("any")
assert.NoError(t, err)
assert.NotNil(t, conn)
})

t.Run("mockDriverCtx", func(t *testing.T) {
d := New(&mockDriverCtx{}, NewMultiHook(&mockHook{}))
connect, err := d.Open("any")
assert.NoError(t, err)
assert.NotNil(t, connect)

driverContext := d.(driver.DriverContext)
openConnector, err := driverContext.OpenConnector("any")
connect, err = openConnector.Connect(context.Background())
assert.NoError(t, err)
assert.NotNil(t, connect)
assert.NotNil(t, openConnector.Driver())
})

}
158 changes: 3 additions & 155 deletions hook.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,16 +14,16 @@ type (
}
ConnHook interface {
BeforeExecContext(ctx context.Context, query string, args []driver.NamedValue, err error) (context.Context, string, []driver.NamedValue, error)
AfterExecContext(ctx context.Context, query string, args []driver.NamedValue, r driver.Result, err error) (context.Context, driver.Result, error)
AfterExecContext(ctx context.Context, query string, args []driver.NamedValue, dr driver.Result, err error) (context.Context, driver.Result, error)

BeforeBeginTx(ctx context.Context, opts driver.TxOptions, err error) (context.Context, driver.TxOptions, error)
AfterBeginTx(ctx context.Context, opts driver.TxOptions, dd driver.Tx, err error) (context.Context, driver.Tx, error)
AfterBeginTx(ctx context.Context, opts driver.TxOptions, dt driver.Tx, err error) (context.Context, driver.Tx, error)

BeforeQueryContext(ctx context.Context, query string, args []driver.NamedValue, err error) (context.Context, string, []driver.NamedValue, error)
AfterQueryContext(ctx context.Context, query string, args []driver.NamedValue, rows driver.Rows, err error) (context.Context, driver.Rows, error)

BeforePrepareContext(ctx context.Context, query string, err error) (context.Context, string, error)
AfterPrepareContext(ctx context.Context, query string, s driver.Stmt, err error) (context.Context, driver.Stmt, error)
AfterPrepareContext(ctx context.Context, query string, ds driver.Stmt, err error) (context.Context, driver.Stmt, error)
}
ConnectorHook interface {
BeforeConnect(ctx context.Context, err error) (context.Context, error)
Expand All @@ -41,156 +41,4 @@ type (
BeforeStmtExecContext(ctx context.Context, query string, args []driver.NamedValue, err error) (context.Context, []driver.NamedValue, error)
AfterStmtExecContext(ctx context.Context, query string, args []driver.NamedValue, r driver.Result, err error) (context.Context, driver.Result, error)
}
Hooks struct {
hooks []Hook
}
)

func NewMultiHook(hooks ...Hook) Hook {
return &Hooks{hooks: hooks}
}

func (h *Hooks) BeforeConnect(ctx context.Context, err error) (context.Context, error) {
for _, hook := range h.hooks {
ctx, err = hook.BeforeConnect(ctx, err)
}

return ctx, err
}

func (h *Hooks) AfterConnect(ctx context.Context, dc driver.Conn, err error) (context.Context, driver.Conn, error) {
for _, hook := range h.hooks {
ctx, dc, err = hook.AfterConnect(ctx, dc, err)
}

return ctx, dc, err
}

func (h *Hooks) BeforeExecContext(ctx context.Context, query string, args []driver.NamedValue, err error) (context.Context, string, []driver.NamedValue, error) {
for _, hook := range h.hooks {
ctx, query, args, err = hook.BeforeExecContext(ctx, query, args, err)
}

return ctx, query, args, err
}

func (h *Hooks) AfterExecContext(ctx context.Context, query string, args []driver.NamedValue, r driver.Result, err error) (context.Context, driver.Result, error) {
for _, hook := range h.hooks {
ctx, r, err = hook.AfterExecContext(ctx, query, args, r, err)
}

return ctx, r, err
}

func (h *Hooks) BeforeBeginTx(ctx context.Context, opts driver.TxOptions, err error) (context.Context, driver.TxOptions, error) {
for _, hook := range h.hooks {
ctx, opts, err = hook.BeforeBeginTx(ctx, opts, err)
}

return ctx, opts, err
}

func (h *Hooks) AfterBeginTx(ctx context.Context, opts driver.TxOptions, dd driver.Tx, err error) (context.Context, driver.Tx, error) {
for _, hook := range h.hooks {
ctx, dd, err = hook.AfterBeginTx(ctx, opts, dd, err)
}

return ctx, dd, err
}

func (h *Hooks) BeforeQueryContext(ctx context.Context, query string, args []driver.NamedValue, err error) (context.Context, string, []driver.NamedValue, error) {
for _, hook := range h.hooks {
ctx, query, args, err = hook.BeforeQueryContext(ctx, query, args, err)
}

return ctx, query, args, err
}

func (h *Hooks) AfterQueryContext(ctx context.Context, query string, args []driver.NamedValue, rows driver.Rows, err error) (context.Context, driver.Rows, error) {
for _, hook := range h.hooks {
ctx, rows, err = hook.AfterQueryContext(ctx, query, args, rows, err)

}

return ctx, rows, err
}

func (h *Hooks) BeforePrepareContext(ctx context.Context, query string, err error) (context.Context, string, error) {
for _, hook := range h.hooks {
ctx, query, err = hook.BeforePrepareContext(ctx, query, err)
}

return ctx, query, err
}

func (h *Hooks) AfterPrepareContext(ctx context.Context, query string, s driver.Stmt, err error) (context.Context, driver.Stmt, error) {
for _, hook := range h.hooks {
ctx, s, err = hook.AfterPrepareContext(ctx, query, s, err)
}

return ctx, s, err
}

func (h *Hooks) BeforeCommit(ctx context.Context, err error) (context.Context, error) {
for _, hook := range h.hooks {
ctx, err = hook.BeforeCommit(ctx, err)
}

return ctx, err
}

func (h *Hooks) AfterCommit(ctx context.Context, err error) (context.Context, error) {
for _, hook := range h.hooks {
ctx, err = hook.AfterCommit(ctx, err)
}

return ctx, err
}

func (h *Hooks) BeforeRollback(ctx context.Context, err error) (context.Context, error) {
for _, hook := range h.hooks {
ctx, err = hook.BeforeRollback(ctx, err)
}

return ctx, err
}

func (h *Hooks) AfterRollback(ctx context.Context, err error) (context.Context, error) {
for _, hook := range h.hooks {
ctx, err = hook.AfterRollback(ctx, err)
}

return ctx, err
}

func (h *Hooks) BeforeStmtQueryContext(ctx context.Context, query string, args []driver.NamedValue, err error) (context.Context, []driver.NamedValue, error) {
for _, hook := range h.hooks {
ctx, args, err = hook.BeforeStmtQueryContext(ctx, query, args, err)
}

return ctx, args, err
}

func (h *Hooks) AfterStmtQueryContext(ctx context.Context, query string, args []driver.NamedValue, rows driver.Rows, err error) (context.Context, driver.Rows, error) {
for _, hook := range h.hooks {
ctx, rows, err = hook.AfterStmtQueryContext(ctx, query, args, rows, err)
}

return ctx, rows, err
}

func (h *Hooks) BeforeStmtExecContext(ctx context.Context, query string, args []driver.NamedValue, err error) (context.Context, []driver.NamedValue, error) {
for _, hook := range h.hooks {
ctx, args, err = hook.BeforeStmtExecContext(ctx, query, args, err)
}

return ctx, args, err
}

func (h *Hooks) AfterStmtExecContext(ctx context.Context, query string, args []driver.NamedValue, r driver.Result, err error) (context.Context, driver.Result, error) {
for _, hook := range h.hooks {
ctx, r, err = hook.AfterStmtExecContext(ctx, query, args, r, err)
}

return ctx, r, err
}
Loading