Commit b3fae7a4 authored by Martina Ferrari's avatar Martina Ferrari

New upstream version 1.3.0

parent 42a0bf16
language: go language: go
sudo: false
go: go:
- 1.2 - 1.2.x
- 1.3 - 1.3.x
- 1.4 - 1.4 # has no cover tool for latest releases
- release - 1.5.x
- tip - 1.6.x
- 1.7.x
- 1.8.x
# - tip # sadly fails most of the times
script: script:
- go test -v ./... - go vet
- go test -race ./... - test -z "$(go fmt ./...)" # fail if not formatted properly
- go test -race -coverprofile=coverage.txt -covermode=atomic
after_success:
- bash <(curl -s https://codecov.io/bash)
The three clause BSD license (http://en.wikipedia.org/wiki/BSD_licenses) The three clause BSD license (http://en.wikipedia.org/wiki/BSD_licenses)
Copyright (c) 2013-2015, DataDog.lt team Copyright (c) 2013-2017, DATA-DOG team
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without Redistribution and use in source and binary forms, with or without
......
[![Build Status](https://travis-ci.org/DATA-DOG/go-sqlmock.png)](https://travis-ci.org/DATA-DOG/go-sqlmock) [![Build Status](https://travis-ci.org/DATA-DOG/go-sqlmock.svg)](https://travis-ci.org/DATA-DOG/go-sqlmock)
[![GoDoc](https://godoc.org/github.com/DATA-DOG/go-sqlmock?status.png)](https://godoc.org/github.com/DATA-DOG/go-sqlmock) [![GoDoc](https://godoc.org/github.com/DATA-DOG/go-sqlmock?status.svg)](https://godoc.org/github.com/DATA-DOG/go-sqlmock)
[![codecov.io](https://codecov.io/github/DATA-DOG/go-sqlmock/branch/master/graph/badge.svg)](https://codecov.io/github/DATA-DOG/go-sqlmock)
# Sql driver mock for Golang # Sql driver mock for Golang
This is a **mock** driver as **database/sql/driver** which is very flexible and pragmatic to **sqlmock** is a mock library implementing [sql/driver](https://godoc.org/database/sql/driver). Which has one and only
manage and mock expected queries. All the expectations should be met and all queries and actions purpose - to simulate any **sql** driver behavior in tests, without needing a real database connection. It helps to
triggered should be mocked in order to pass a test. The package has no 3rd party dependencies. maintain correct **TDD** workflow.
**NOTE:** regarding major issues #20 and #9 the **api** has changed to support concurrency and more than - this library is now complete and stable. (you may not find new changes for this reason)
one database connection. - supports concurrency and multiple connections.
- supports **go1.8** Context related feature mocking and Named sql parameters.
- does not require any modifications to your source code.
- the driver allows to mock any sql driver method behavior.
- has strict by default expectation order matching.
- has no third party dependencies.
If you need an old version, checkout **go-sqlmock** at gopkg.in: **NOTE:** in **v1.2.0** **sqlmock.Rows** has changed to struct from interface, if you were using any type references to that
interface, you will need to switch it to a pointer struct type. Also, **sqlmock.Rows** were used to implement **driver.Rows**
go get gopkg.in/DATA-DOG/go-sqlmock.v0 interface, which was not required or useful for mocking and was removed. Hope it will not cause issues.
Otherwise use the **v1** branch from master which should be stable afterwards, because all the issues which
were known will be fixed in this version.
## Install ## Install
go get gopkg.in/DATA-DOG/go-sqlmock.v1 go get gopkg.in/DATA-DOG/go-sqlmock.v1
Or take an older version:
go get gopkg.in/DATA-DOG/go-sqlmock.v0
## Documentation and Examples ## Documentation and Examples
Visit [godoc](http://godoc.org/github.com/DATA-DOG/go-sqlmock) for general examples and public api reference. Visit [godoc](http://godoc.org/github.com/DATA-DOG/go-sqlmock) for general examples and public api reference.
...@@ -91,7 +90,7 @@ import ( ...@@ -91,7 +90,7 @@ import (
"fmt" "fmt"
"testing" "testing"
"github.com/DATA-DOG/go-sqlmock" "gopkg.in/DATA-DOG/go-sqlmock.v1"
) )
// a successful case // a successful case
...@@ -145,12 +144,65 @@ func TestShouldRollbackStatUpdatesOnFailure(t *testing.T) { ...@@ -145,12 +144,65 @@ func TestShouldRollbackStatUpdatesOnFailure(t *testing.T) {
} }
``` ```
## Matching arguments like time.Time
There may be arguments which are of `struct` type and cannot be compared easily by value like `time.Time`. In this case
**sqlmock** provides an [Argument](https://godoc.org/github.com/DATA-DOG/go-sqlmock#Argument) interface which
can be used in more sophisticated matching. Here is a simple example of time argument matching:
``` go
type AnyTime struct{}
// Match satisfies sqlmock.Argument interface
func (a AnyTime) Match(v driver.Value) bool {
_, ok := v.(time.Time)
return ok
}
func TestAnyTimeArgument(t *testing.T) {
t.Parallel()
db, mock, err := New()
if err != nil {
t.Errorf("an error '%s' was not expected when opening a stub database connection", err)
}
defer db.Close()
mock.ExpectExec("INSERT INTO users").
WithArgs("john", AnyTime{}).
WillReturnResult(NewResult(1, 1))
_, err = db.Exec("INSERT INTO users(name, created_at) VALUES (?, ?)", "john", time.Now())
if err != nil {
t.Errorf("error '%s' was not expected, while inserting a row", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Errorf("there were unfulfilled expections: %s", err)
}
}
```
It only asserts that argument is of `time.Time` type.
## Run tests ## Run tests
go test -race go test -race
## Changes ## Change Log
- **2017-09-01** - it is now possible to expect that prepared statement will be closed,
using **ExpectedPrepare.WillBeClosed**.
- **2017-02-09** - implemented support for **go1.8** features. **Rows** interface was changed to struct
but contains all methods as before and should maintain backwards compatibility. **ExpectedQuery.WillReturnRows** may now
accept multiple row sets.
- **2016-11-02** - `db.Prepare()` was not validating expected prepare SQL
query. It should still be validated even if Exec or Query is not
executed on that prepared statement.
- **2016-02-23** - added **sqlmock.AnyArg()** function to provide any kind
of argument matcher.
- **2016-02-23** - convert expected arguments to driver.Value as natural
driver does, the change may affect time.Time comparison and will be
stricter. See [issue](https://github.com/DATA-DOG/go-sqlmock/issues/31).
- **2015-08-27** - **v1** api change, concurrency support, all known issues fixed. - **2015-08-27** - **v1** api change, concurrency support, all known issues fixed.
- **2014-08-16** instead of **panic** during reflect type mismatch when comparing query arguments - now return error - **2014-08-16** instead of **panic** during reflect type mismatch when comparing query arguments - now return error
- **2014-08-14** added **sqlmock.NewErrorResult** which gives an option to return driver.Result with errors for - **2014-08-14** added **sqlmock.NewErrorResult** which gives an option to return driver.Result with errors for
......
package sqlmock
import "database/sql/driver"
// Argument interface allows to match
// any argument in specific way when used with
// ExpectedQuery and ExpectedExec expectations.
type Argument interface {
Match(driver.Value) bool
}
// AnyArg will return an Argument which can
// match any kind of arguments.
//
// Useful for time.Time or similar kinds of arguments.
func AnyArg() Argument {
return anyArgument{}
}
type anyArgument struct{}
func (a anyArgument) Match(_ driver.Value) bool {
return true
}
package sqlmock
import (
"database/sql/driver"
"testing"
"time"
)
type AnyTime struct{}
// Match satisfies sqlmock.Argument interface
func (a AnyTime) Match(v driver.Value) bool {
_, ok := v.(time.Time)
return ok
}
func TestAnyTimeArgument(t *testing.T) {
t.Parallel()
db, mock, err := New()
if err != nil {
t.Errorf("an error '%s' was not expected when opening a stub database connection", err)
}
defer db.Close()
mock.ExpectExec("INSERT INTO users").
WithArgs("john", AnyTime{}).
WillReturnResult(NewResult(1, 1))
_, err = db.Exec("INSERT INTO users(name, created_at) VALUES (?, ?)", "john", time.Now())
if err != nil {
t.Errorf("error '%s' was not expected, while inserting a row", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Errorf("there were unfulfilled expections: %s", err)
}
}
func TestByteSliceArgument(t *testing.T) {
t.Parallel()
db, mock, err := New()
if err != nil {
t.Errorf("an error '%s' was not expected when opening a stub database connection", err)
}
defer db.Close()
username := []byte("user")
mock.ExpectExec("INSERT INTO users").WithArgs(username).WillReturnResult(NewResult(1, 1))
_, err = db.Exec("INSERT INTO users(username) VALUES (?)", username)
if err != nil {
t.Errorf("error '%s' was not expected, while inserting a row", err)
}
if err := mock.ExpectationsWereMet(); err != nil {
t.Errorf("there were unfulfilled expections: %s", err)
}
}
...@@ -39,7 +39,7 @@ func (d *mockDriver) Open(dsn string) (driver.Conn, error) { ...@@ -39,7 +39,7 @@ func (d *mockDriver) Open(dsn string) (driver.Conn, error) {
// and a mock to manage expectations. // and a mock to manage expectations.
// Pings db so that all expectations could be // Pings db so that all expectations could be
// asserted. // asserted.
func New() (db *sql.DB, mock Sqlmock, err error) { func New() (*sql.DB, Sqlmock, error) {
pool.Lock() pool.Lock()
dsn := fmt.Sprintf("sqlmock_db_%d", pool.counter) dsn := fmt.Sprintf("sqlmock_db_%d", pool.counter)
pool.counter++ pool.counter++
...@@ -48,9 +48,31 @@ func New() (db *sql.DB, mock Sqlmock, err error) { ...@@ -48,9 +48,31 @@ func New() (db *sql.DB, mock Sqlmock, err error) {
pool.conns[dsn] = smock pool.conns[dsn] = smock
pool.Unlock() pool.Unlock()
db, err = sql.Open("sqlmock", dsn) return smock.open()
if err != nil { }
return
// NewWithDSN creates sqlmock database connection
// with a specific DSN and a mock to manage expectations.
// Pings db so that all expectations could be asserted.
//
// This method is introduced because of sql abstraction
// libraries, which do not provide a way to initialize
// with sql.DB instance. For example GORM library.
//
// Note, it will error if attempted to create with an
// already used dsn
//
// It is not recommended to use this method, unless you
// really need it and there is no other way around.
func NewWithDSN(dsn string) (*sql.DB, Sqlmock, error) {
pool.Lock()
if _, ok := pool.conns[dsn]; ok {
pool.Unlock()
return nil, nil, fmt.Errorf("cannot create a new mock database with the same dsn: %s", dsn)
} }
return db, smock, db.Ping() smock := &sqlmock{dsn: dsn, drv: pool, ordered: true}
pool.conns[dsn] = smock
pool.Unlock()
return smock.open()
} }
...@@ -5,6 +5,10 @@ import ( ...@@ -5,6 +5,10 @@ import (
"testing" "testing"
) )
type void struct{}
func (void) Print(...interface{}) {}
func ExampleNew() { func ExampleNew() {
db, mock, err := New() db, mock, err := New()
if err != nil { if err != nil {
...@@ -71,6 +75,9 @@ func TestTwoOpenConnectionsOnTheSameDSN(t *testing.T) { ...@@ -71,6 +75,9 @@ func TestTwoOpenConnectionsOnTheSameDSN(t *testing.T) {
t.Errorf("expected no error, but got: %s", err) t.Errorf("expected no error, but got: %s", err)
} }
db2, mock2, err := New() db2, mock2, err := New()
if err != nil {
t.Errorf("expected no error, but got: %s", err)
}
if len(pool.conns) != 2 { if len(pool.conns) != 2 {
t.Errorf("expected 2 connection in pool, but there is: %d", len(pool.conns)) t.Errorf("expected 2 connection in pool, but there is: %d", len(pool.conns))
} }
...@@ -82,3 +89,24 @@ func TestTwoOpenConnectionsOnTheSameDSN(t *testing.T) { ...@@ -82,3 +89,24 @@ func TestTwoOpenConnectionsOnTheSameDSN(t *testing.T) {
t.Errorf("expected not the same mock instance, but it is the same") t.Errorf("expected not the same mock instance, but it is the same")
} }
} }
func TestWrongDSN(t *testing.T) {
t.Parallel()
db, _, _ := New()
defer db.Close()
if _, err := db.Driver().Open("wrong_dsn"); err == nil {
t.Error("expected error on Open")
}
}
func TestNewDSN(t *testing.T) {
if _, _, err := NewWithDSN("sqlmock_db_99"); err != nil {
t.Errorf("expected no error on NewWithDSN, but got: %s", err)
}
}
func TestDuplicateNewDSN(t *testing.T) {
if _, _, err := NewWithDSN("sqlmock_db_1"); err == nil {
t.Error("expected error on NewWithDSN")
}
}
...@@ -3,19 +3,12 @@ package sqlmock ...@@ -3,19 +3,12 @@ package sqlmock
import ( import (
"database/sql/driver" "database/sql/driver"
"fmt" "fmt"
"reflect"
"regexp" "regexp"
"strings" "strings"
"sync" "sync"
"time"
) )
// Argument interface allows to match
// any argument in specific way when used with
// ExpectedQuery and ExpectedExec expectations.
type Argument interface {
Match(driver.Value) bool
}
// an expectation interface // an expectation interface
type expectation interface { type expectation interface {
fulfilled() bool fulfilled() bool
...@@ -61,6 +54,7 @@ func (e *ExpectedClose) String() string { ...@@ -61,6 +54,7 @@ func (e *ExpectedClose) String() string {
// returned by *Sqlmock.ExpectBegin. // returned by *Sqlmock.ExpectBegin.
type ExpectedBegin struct { type ExpectedBegin struct {
commonExpectation commonExpectation
delay time.Duration
} }
// WillReturnError allows to set an error for *sql.DB.Begin action // WillReturnError allows to set an error for *sql.DB.Begin action
...@@ -78,6 +72,13 @@ func (e *ExpectedBegin) String() string { ...@@ -78,6 +72,13 @@ func (e *ExpectedBegin) String() string {
return msg return msg
} }
// WillDelayFor allows to specify duration for which it will delay
// result. May be used together with Context
func (e *ExpectedBegin) WillDelayFor(duration time.Duration) *ExpectedBegin {
e.delay = duration
return e
}
// ExpectedCommit is used to manage *sql.Tx.Commit expectation // ExpectedCommit is used to manage *sql.Tx.Commit expectation
// returned by *Sqlmock.ExpectCommit. // returned by *Sqlmock.ExpectCommit.
type ExpectedCommit struct { type ExpectedCommit struct {
...@@ -125,7 +126,8 @@ func (e *ExpectedRollback) String() string { ...@@ -125,7 +126,8 @@ func (e *ExpectedRollback) String() string {
// Returned by *Sqlmock.ExpectQuery. // Returned by *Sqlmock.ExpectQuery.
type ExpectedQuery struct { type ExpectedQuery struct {
queryBasedExpectation queryBasedExpectation
rows driver.Rows rows driver.Rows
delay time.Duration
} }
// WithArgs will match given expected args to actual database query arguments. // WithArgs will match given expected args to actual database query arguments.
...@@ -142,16 +144,16 @@ func (e *ExpectedQuery) WillReturnError(err error) *ExpectedQuery { ...@@ -142,16 +144,16 @@ func (e *ExpectedQuery) WillReturnError(err error) *ExpectedQuery {
return e return e
} }
// WillReturnRows specifies the set of resulting rows that will be returned // WillDelayFor allows to specify duration for which it will delay
// by the triggered query // result. May be used together with Context
func (e *ExpectedQuery) WillReturnRows(rows driver.Rows) *ExpectedQuery { func (e *ExpectedQuery) WillDelayFor(duration time.Duration) *ExpectedQuery {
e.rows = rows e.delay = duration
return e return e
} }
// String returns string representation // String returns string representation
func (e *ExpectedQuery) String() string { func (e *ExpectedQuery) String() string {
msg := "ExpectedQuery => expecting Query or QueryRow which:" msg := "ExpectedQuery => expecting Query, QueryContext or QueryRow which:"
msg += "\n - matches sql: '" + e.sqlRegex.String() + "'" msg += "\n - matches sql: '" + e.sqlRegex.String() + "'"
if len(e.args) == 0 { if len(e.args) == 0 {
...@@ -165,12 +167,7 @@ func (e *ExpectedQuery) String() string { ...@@ -165,12 +167,7 @@ func (e *ExpectedQuery) String() string {
} }
if e.rows != nil { if e.rows != nil {
msg += "\n - should return rows:\n" msg += fmt.Sprintf("\n - %s", e.rows)
rs, _ := e.rows.(*rows)
for i, row := range rs.rows {
msg += fmt.Sprintf(" %d - %+v\n", i, row)
}
msg = strings.TrimSpace(msg)
} }
if e.err != nil { if e.err != nil {
...@@ -185,6 +182,7 @@ func (e *ExpectedQuery) String() string { ...@@ -185,6 +182,7 @@ func (e *ExpectedQuery) String() string {
type ExpectedExec struct { type ExpectedExec struct {
queryBasedExpectation queryBasedExpectation
result driver.Result result driver.Result
delay time.Duration
} }
// WithArgs will match given expected args to actual database exec operation arguments. // WithArgs will match given expected args to actual database exec operation arguments.
...@@ -201,9 +199,16 @@ func (e *ExpectedExec) WillReturnError(err error) *ExpectedExec { ...@@ -201,9 +199,16 @@ func (e *ExpectedExec) WillReturnError(err error) *ExpectedExec {
return e return e
} }
// WillDelayFor allows to specify duration for which it will delay
// result. May be used together with Context
func (e *ExpectedExec) WillDelayFor(duration time.Duration) *ExpectedExec {
e.delay = duration
return e
}
// String returns string representation // String returns string representation
func (e *ExpectedExec) String() string { func (e *ExpectedExec) String() string {
msg := "ExpectedExec => expecting Exec which:" msg := "ExpectedExec => expecting Exec or ExecContext which:"
msg += "\n - matches sql: '" + e.sqlRegex.String() + "'" msg += "\n - matches sql: '" + e.sqlRegex.String() + "'"
if len(e.args) == 0 { if len(e.args) == 0 {
...@@ -247,10 +252,13 @@ func (e *ExpectedExec) WillReturnResult(result driver.Result) *ExpectedExec { ...@@ -247,10 +252,13 @@ func (e *ExpectedExec) WillReturnResult(result driver.Result) *ExpectedExec {
// Returned by *Sqlmock.ExpectPrepare. // Returned by *Sqlmock.ExpectPrepare.
type ExpectedPrepare struct { type ExpectedPrepare struct {
commonExpectation commonExpectation
mock *sqlmock mock *sqlmock
sqlRegex *regexp.Regexp sqlRegex *regexp.Regexp
statement driver.Stmt statement driver.Stmt
closeErr error closeErr error
mustBeClosed bool
wasClosed bool
delay time.Duration
} }
// WillReturnError allows to set an error for the expected *sql.DB.Prepare or *sql.Tx.Prepare action. // WillReturnError allows to set an error for the expected *sql.DB.Prepare or *sql.Tx.Prepare action.
...@@ -259,12 +267,26 @@ func (e *ExpectedPrepare) WillReturnError(err error) *ExpectedPrepare { ...@@ -259,12 +267,26 @@ func (e *ExpectedPrepare) WillReturnError(err error) *ExpectedPrepare {
return e return e
} }
// WillReturnCloseError allows to set an error for this prapared statement Close action // WillReturnCloseError allows to set an error for this prepared statement Close action
func (e *ExpectedPrepare) WillReturnCloseError(err error) *ExpectedPrepare { func (e *ExpectedPrepare) WillReturnCloseError(err error) *ExpectedPrepare {
e.closeErr = err e.closeErr = err
return e return e
} }
// WillDelayFor allows to specify duration for which it will delay
// result. May be used together with Context
func (e *ExpectedPrepare) WillDelayFor(duration time.Duration) *ExpectedPrepare {
e.delay = duration
return e
}
// WillBeClosed expects this prepared statement to
// be closed.
func (e *ExpectedPrepare) WillBeClosed() *ExpectedPrepare {
e.mustBeClosed = true
return e
}
// ExpectQuery allows to expect Query() or QueryRow() on this prepared statement. // ExpectQuery allows to expect Query() or QueryRow() on this prepared statement.
// this method is convenient in order to prevent duplicating sql query string matching. // this method is convenient in order to prevent duplicating sql query string matching.
func (e *ExpectedPrepare) ExpectQuery() *ExpectedQuery { func (e *ExpectedPrepare) ExpectQuery() *ExpectedQuery {
...@@ -307,63 +329,25 @@ type queryBasedExpectation struct { ...@@ -307,63 +329,25 @@ type queryBasedExpectation struct {
args []driver.Value args []driver.Value
} }
func (e *queryBasedExpectation) attemptMatch(sql string, args []driver.Value) (ret bool) { func (e *queryBasedExpectation) attemptMatch(sql string, args []namedValue) (err error) {
if !e.queryMatches(sql) { if !e.queryMatches(sql) {
return return fmt.Errorf(`could not match sql: "%s" with expected regexp "%s"`, sql, e.sqlRegex.String())
} }
defer recover() // ignore panic since we attempt a match // catch panic
defer func() {
if e := recover(); e != nil {
_, ok := e.(error)
if !ok {
err = fmt.Errorf(e.(string))
}
}
}()
if e.argsMatches(args) { err = e.argsMatches(args)
return true
}
return return
} }
func (e *queryBasedExpectation) queryMatches(sql string) bool { func (e *queryBasedExpectation) queryMatches(sql string) bool {
return e.sqlRegex.MatchString(sql) return e.sqlRegex.MatchString(sql)
} }
func (e *queryBasedExpectation) argsMatches(args []driver.Value) bool {
if nil == e.args {
return true
}
if len(args) != len(e.args) {
return false
}
for k, v := range args {
matcher, ok := e.args[k].(Argument)
if ok {
if !matcher.Match(v) {
return false
}
continue
}
vi := reflect.ValueOf(v)
ai := reflect.ValueOf(e.args[k])
switch vi.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if vi.Int() != ai.Int() {
return false
}
case reflect.Float32, reflect.Float64:
if vi.Float() != ai.Float() {
return false
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if vi.Uint() != ai.Uint() {
return false
}
case reflect.String:
if vi.String() != ai.String() {
return false
}
default:
// compare types like time.Time based on type only
if vi.Kind() != ai.Kind() {
return false
}
}
}
return true
}
// +build !go1.8
package sqlmock
import (
"database/sql/driver"
"fmt"
"reflect"
)
// WillReturnRows specifies the set of resulting rows that will be returned
// by the triggered query
func (e *ExpectedQuery) WillReturnRows(rows *Rows) *ExpectedQuery {
e.rows = &rowSets{sets: []*Rows{rows}}
return e
}
func (e *queryBasedExpectation) argsMatches(args []namedValue) error {
if nil == e.args {
return nil
}
if len(args) != len(e.args) {
return fmt.Errorf("expected %d, but got %d arguments", len(e.args), len(args))
}
for k, v := range args {
// custom argument matcher
matcher, ok := e.args[k].(Argument)
if ok {
// @TODO: does it make sense to pass value instead of named value?
if !matcher.Match(v.Value) {
return fmt.Errorf("matcher %T could not match %d argument %T - %+v", matcher, k, args[k], args[k])
}
continue
}
dval := e.args[k]
// convert to driver converter
darg, err := driver.DefaultParameterConverter.ConvertValue(dval)
if err != nil {
return fmt.Errorf("could not convert %d argument %T - %+v to driver value: %s", k, e.args[k], e.args[k], err)
}
if !driver.IsValue(darg) {
return fmt.Errorf("argument %d: non-subset type %T returned from Value", k, darg)
}
if !reflect.DeepEqual(darg, v.Value) {
return fmt.Errorf("argument %d expected [%T - %+v] does not match actual [%T - %+v]", k, darg, darg, v.Value, v.Value)
}
}
return nil
}
// +build go1.8
package sqlmock
import (
"database/sql"
"database/sql/driver"
"fmt"
"reflect"
)
// WillReturnRows specifies the set of resulting rows that will be returned
// by the triggered query
func (e *ExpectedQuery) WillReturnRows(rows ...*Rows) *ExpectedQuery {
sets := make([]*Rows, len(rows))
for i, r := range rows {
sets[i] = r
}
e.rows = &rowSets{sets: sets}
return e
}
func (e *queryBasedExpectation) argsMatches(args []namedValue) error {