expectations_go18.go

Documentation: github.com/DATA-DOG/go-sqlmock

     1  //go:build go1.8
     2  // +build go1.8
     3  
     4  package sqlmock
     5  
     6  import (
     7  	"database/sql"
     8  	"database/sql/driver"
     9  	"fmt"
    10  	"reflect"
    11  )
    12  
    13  // WillReturnRows specifies the set of resulting rows that will be returned
    14  // by the triggered query
    15  func (e *ExpectedQuery) WillReturnRows(rows ...*Rows) *ExpectedQuery {
    16  	defs := 0
    17  	sets := make([]*Rows, len(rows))
    18  	for i, r := range rows {
    19  		sets[i] = r
    20  		if r.def != nil {
    21  			defs++
    22  		}
    23  	}
    24  	if defs > 0 && defs == len(sets) {
    25  		e.rows = &rowSetsWithDefinition{&rowSets{sets: sets, ex: e}}
    26  	} else {
    27  		e.rows = &rowSets{sets: sets, ex: e}
    28  	}
    29  	return e
    30  }
    31  
    32  func (e *queryBasedExpectation) argsMatches(args []driver.NamedValue) error {
    33  	if nil == e.args {
    34  		if e.noArgs && len(args) > 0 {
    35  			return fmt.Errorf("expected 0, but got %d arguments", len(args))
    36  		}
    37  		return nil
    38  	}
    39  	if len(args) != len(e.args) {
    40  		return fmt.Errorf("expected %d, but got %d arguments", len(e.args), len(args))
    41  	}
    42  	// @TODO should we assert either all args are named or ordinal?
    43  	for k, v := range args {
    44  		// custom argument matcher
    45  		matcher, ok := e.args[k].(Argument)
    46  		if ok {
    47  			if !matcher.Match(v.Value) {
    48  				return fmt.Errorf("matcher %T could not match %d argument %T - %+v", matcher, k, args[k], args[k])
    49  			}
    50  			continue
    51  		}
    52  
    53  		dval := e.args[k]
    54  		if named, isNamed := dval.(sql.NamedArg); isNamed {
    55  			dval = named.Value
    56  			if v.Name != named.Name {
    57  				return fmt.Errorf("named argument %d: name: \"%s\" does not match expected: \"%s\"", k, v.Name, named.Name)
    58  			}
    59  		} else if k+1 != v.Ordinal {
    60  			return fmt.Errorf("argument %d: ordinal position: %d does not match expected: %d", k, k+1, v.Ordinal)
    61  		}
    62  
    63  		// convert to driver converter
    64  		darg, err := e.converter.ConvertValue(dval)
    65  		if err != nil {
    66  			return fmt.Errorf("could not convert %d argument %T - %+v to driver value: %s", k, e.args[k], e.args[k], err)
    67  		}
    68  
    69  		if !reflect.DeepEqual(darg, v.Value) {
    70  			return fmt.Errorf("argument %d expected [%T - %+v] does not match actual [%T - %+v]", k, darg, darg, v.Value, v.Value)
    71  		}
    72  	}
    73  	return nil
    74  }
    75  
    76  func (e *queryBasedExpectation) attemptArgMatch(args []driver.NamedValue) (err error) {
    77  	// catch panic
    78  	defer func() {
    79  		if e := recover(); e != nil {
    80  			_, ok := e.(error)
    81  			if !ok {
    82  				err = fmt.Errorf(e.(string))
    83  			}
    84  		}
    85  	}()
    86  
    87  	err = e.argsMatches(args)
    88  	return
    89  }
    90
View as plain text