Open platform to collect and prioritize feedback
use real postgres database
goenning24ea6418d6b4
diff --git a/.test.env b/.test.envindex 6ee64458d..2d016cef8 100644--- a/.test.env+++ b/.test.env@@ -1,4 +1,4 @@GO_ENV=test-DATABASE_URL=postgres://wechy:wechy-pw@localhost:5555/wechy?sslmode=disable+DATABASE_URL=postgres://wechy_test:wechy_test-pw@localhost:5566/wechy_test?sslmode=disableAUTH_ENDPOINT=http://login.test.canhearyou.com:3000JWT_SECRET=I1$$MplJ-007A8]G#RE0VVfvv:I~o6+2yA0@)>2|{K$Z1628z9;w7lAsZ\ No newline at end of filediff --git a/.travis.yml b/.travis.ymlindex a9807ef10..5dd85766a 100644--- a/.travis.yml+++ b/.travis.yml@@ -17,6 +17,7 @@ install:- npm i -g yarn- go get github.com/mattn/goveralls- go get github.com/joho/godotenv/cmd/godotenv+ - docker compose up -d pgtest- yarnscript:diff --git a/app/postgres/feedback_test.go b/app/postgres/feedback_test.goindex d627c2068..bdb2eb1b8 100644--- a/app/postgres/feedback_test.go+++ b/app/postgres/feedback_test.go@@ -1,70 +1,37 @@package postgres_testimport (- "database/sql/driver""testing""time"- sqlmock "gopkg.in/DATA-DOG/go-sqlmock.v1"-- "github.com/WeCanHearYou/wechy/app"- "github.com/WeCanHearYou/wechy/app/feedback""github.com/WeCanHearYou/wechy/app/postgres". "github.com/onsi/gomega")-func TestIdeaService_GetAll_Error(t *testing.T) {- RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()-- mock.ExpectQuery("SELECT (.*) FROM ideas (.*) JOIN users").WithArgs(2134).WillReturnError(driver.ErrBadConn)-- svc := &postgres.IdeaService{DB: db}- ideas, err := svc.GetAll(2134)-- Expect(ideas).To(BeEmpty())- Expect(err).NotTo(BeNil())-}-func TestIdeaService_GetAll(t *testing.T) {RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()+ db := setup()+ defer teardown(db)now := time.Now()- rows := sqlmock.NewRows([]string{"id", "title", "description", "created_on", "u_id", "u_name", "u_email"})- rows.AddRow(1, "Idea #1", "Description #1", now, 1, "Jon Snow", "[email protected]")- rows.AddRow(2, "Idea #2", "Description #2", now, 2, "Arya Start", "[email protected]")- mock.ExpectQuery("SELECT (.*) FROM ideas (.*) JOIN users").WithArgs(2134).WillReturnRows(rows)++ execute(db, "INSERT INTO tenants (name, subdomain, created_on) VALUES ('My Domain Inc.','mydomain', now())")+ execute(db, "INSERT INTO users (name, email, created_on) VALUES ('Jon Snow','[email protected]', now())")+ execute(db, "INSERT INTO users (name, email, created_on) VALUES ('Arya Start','[email protected]', now())")+ execute(db, "INSERT INTO ideas (title, description, created_on, tenant_id, user_id) VALUES ('Idea #1','Description #1', $1, 1, 1)", now)+ execute(db, "INSERT INTO ideas (title, description, created_on, tenant_id, user_id) VALUES ('Idea #2','Description #2', $1, 1, 2)", now)svc := &postgres.IdeaService{DB: db}- ideas, err := svc.GetAll(2134)+ ideas, err := svc.GetAll(1)Expect(err).To(BeNil())Expect(ideas).To(HaveLen(2))- Expect(ideas[0]).To(Equal(&feedback.Idea{- ID: 1,- Title: "Idea #1",- Description: "Description #1",- CreatedOn: now,- User: app.User{- ID: 1,- Name: "Jon Snow",- Email: "[email protected]",- },- }))- Expect(ideas[1]).To(Equal(&feedback.Idea{- ID: 2,- Title: "Idea #2",- Description: "Description #2",- CreatedOn: now,- User: app.User{- ID: 2,- Name: "Arya Start",- Email: "[email protected]",- },- }))++ Expect(ideas[0].Title).To(Equal("Idea #1"))+ Expect(ideas[0].Description).To(Equal("Description #1"))+ Expect(ideas[0].User.Name).To(Equal("Jon Snow"))++ Expect(ideas[1].Title).To(Equal("Idea #2"))+ Expect(ideas[1].Description).To(Equal("Description #2"))+ Expect(ideas[1].User.Name).To(Equal("Arya Start"))}diff --git a/app/postgres/helpers_test.go b/app/postgres/helpers_test.godeleted file mode 100644index 7ca34b505..000000000--- a/app/postgres/helpers_test.go+++ /dev/null@@ -1,14 +0,0 @@-package postgres_test--import (- "database/sql/driver"- "time"-)--type AnyTime struct{}--// Match satisfies sqlmock.Argument interface-func (a AnyTime) Match(v driver.Value) bool {- _, ok := v.(time.Time)- return ok-}diff --git a/app/postgres/identity_test.go b/app/postgres/identity_test.goindex 0535fd83b..ad9a2ec2f 100644--- a/app/postgres/identity_test.go+++ b/app/postgres/identity_test.go@@ -1,12 +1,8 @@package postgres_testimport (- "database/sql"- "database/sql/driver""testing"- sqlmock "gopkg.in/DATA-DOG/go-sqlmock.v1"-"github.com/WeCanHearYou/wechy/app""github.com/WeCanHearYou/wechy/app/identity""github.com/WeCanHearYou/wechy/app/postgres"@@ -15,13 +11,8 @@ import (func TestUserService_GetByEmail_Error(t *testing.T) {RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()-- query := mock.ExpectQuery("SELECT id, name, email FROM users WHERE email = \\$1")- query.WithArgs("[email protected]")- query.WillReturnError(sql.ErrNoRows)+ db := setup()+ defer teardown(db)svc := &postgres.UserService{DB: db}user, err := svc.GetByEmail("[email protected]")@@ -32,41 +23,24 @@ func TestUserService_GetByEmail_Error(t *testing.T) {func TestUserService_GetByEmail(t *testing.T) {RegisterTestingT(t)+ db := setup()+ defer teardown(db)- db, mock, _ := sqlmock.New()- defer db.Close()-- rows := sqlmock.NewRows([]string{"id", "name", "email"}).AddRow(int64(234), "Jon Snow", "[email protected]")- query := mock.ExpectQuery("SELECT id, name, email FROM users WHERE email = \\$1")- query.WithArgs("[email protected]")- query.WillReturnRows(rows)+ execute(db, "INSERT INTO users (name, email, created_on) VALUES ('Jon Snow','[email protected]', now())")svc := &postgres.UserService{DB: db}user, err := svc.GetByEmail("[email protected]")Expect(err).To(BeNil())- Expect(user.ID).To(Equal(int64(234)))+ Expect(user.ID).To(Equal(int64(1)))Expect(user.Name).To(Equal("Jon Snow"))Expect(user.Email).To(Equal("[email protected]"))}func TestUserService_Register(t *testing.T) {RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()-- mock.ExpectBegin()-- query := mock.ExpectQuery("INSERT INTO users \\(name, email, created_on\\) VALUES \\(\\$1, \\$2, \\$3\\) RETURNING id")- query.WithArgs("Jon Snow", "[email protected]", AnyTime{})- query.WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(int64(300)))-- exec := mock.ExpectExec("INSERT INTO user_providers \\(user_id, provider, provider_uid\\) VALUES \\(\\$1, \\$2, \\$3\\)")- exec.WithArgs(int64(300), identity.OAuthFacebookProvider, "123123123")- exec.WillReturnResult(driver.ResultNoRows)-- mock.ExpectCommit()+ db := setup()+ defer teardown(db)svc := &postgres.UserService{DB: db}user := &app.User{@@ -82,30 +56,15 @@ func TestUserService_Register(t *testing.T) {err := svc.Register(user)Expect(err).To(BeNil())- Expect(user.ID).To(Equal(int64(300)))+ Expect(user.ID).To(Equal(int64(1)))+ Expect(user.Name).To(Equal("Jon Snow"))+ Expect(user.Email).To(Equal("[email protected]"))}func TestUserService_Register_MultipleProviders(t *testing.T) {RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()-- mock.ExpectBegin()-- query := mock.ExpectQuery("INSERT INTO users \\(name, email, created_on\\) VALUES \\(\\$1, \\$2, \\$3\\) RETURNING id")- query.WithArgs("Jon Snow", "[email protected]", AnyTime{})- query.WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(int64(300)))-- exec := mock.ExpectExec("INSERT INTO user_providers \\(user_id, provider, provider_uid\\) VALUES \\(\\$1, \\$2, \\$3\\)")- exec.WithArgs(int64(300), identity.OAuthFacebookProvider, "123123123")- exec.WillReturnResult(driver.ResultNoRows)-- exec = mock.ExpectExec("INSERT INTO user_providers \\(user_id, provider, provider_uid\\) VALUES \\(\\$1, \\$2, \\$3\\)")- exec.WithArgs(int64(300), identity.OAuthGoogleProvider, "456456456")- exec.WillReturnResult(driver.ResultNoRows)-- mock.ExpectCommit()+ db := setup()+ defer teardown(db)svc := &postgres.UserService{DB: db}user := &app.User{@@ -125,16 +84,15 @@ func TestUserService_Register_MultipleProviders(t *testing.T) {err := svc.Register(user)Expect(err).To(BeNil())- Expect(user.ID).To(Equal(int64(300)))+ Expect(user.ID).To(Equal(int64(1)))+ Expect(user.Name).To(Equal("Jon Snow"))+ Expect(user.Email).To(Equal("[email protected]"))}-func TestTenantService_GetByDomain_Error(t *testing.T) {+func TestTenantService_GetByDomain_NotFound(t *testing.T) {RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()-- mock.ExpectQuery("SELECT id, name, subdomain FROM tenants WHERE subdomain = \\$1").WithArgs("mydomain").WillReturnError(sql.ErrNoRows)+ db := setup()+ defer teardown(db)svc := &postgres.TenantService{DB: db}tenant, err := svc.GetByDomain("mydomain")@@ -145,17 +103,15 @@ func TestTenantService_GetByDomain_Error(t *testing.T) {func TestTenantService_GetByDomain_Subdomain(t *testing.T) {RegisterTestingT(t)+ db := setup()+ defer teardown(db)- db, mock, _ := sqlmock.New()- defer db.Close()-- rows := sqlmock.NewRows([]string{"id", "name", "subdomain"}).AddRow(int64(234), "My Domain Inc.", "mydomain")- mock.ExpectQuery("SELECT id, name, subdomain FROM tenants WHERE subdomain = \\$1 OR cname = \\$2").WithArgs("mydomain", "mydomain").WillReturnRows(rows)+ execute(db, "INSERT INTO tenants (name, subdomain, created_on) VALUES ('My Domain Inc.','mydomain', now())")svc := &postgres.TenantService{DB: db}tenant, err := svc.GetByDomain("mydomain")- Expect(tenant.ID).To(Equal(int64(234)))+ Expect(tenant.ID).To(Equal(int64(1)))Expect(tenant.Name).To(Equal("My Domain Inc."))Expect(tenant.Domain).To(Equal("mydomain.test.canhearyou.com"))Expect(err).To(BeNil())@@ -163,17 +119,15 @@ func TestTenantService_GetByDomain_Subdomain(t *testing.T) {func TestTenantService_GetByDomain_FullDomain(t *testing.T) {RegisterTestingT(t)+ db := setup()+ defer teardown(db)- db, mock, _ := sqlmock.New()- defer db.Close()-- rows := sqlmock.NewRows([]string{"id", "name", "subdomain"}).AddRow(int64(234), "My Domain Inc.", "mydomain")- mock.ExpectQuery("SELECT id, name, subdomain FROM tenants WHERE subdomain = \\$1 OR cname = \\$2").WithArgs("mydomain", "mydomain.anydomain.com").WillReturnRows(rows)+ execute(db, "INSERT INTO tenants (name, subdomain, cname, created_on) VALUES ('My Domain Inc.','mydomain', 'mydomain.anydomain.com', now())")svc := &postgres.TenantService{DB: db}tenant, err := svc.GetByDomain("mydomain.anydomain.com")- Expect(tenant.ID).To(Equal(int64(234)))+ Expect(tenant.ID).To(Equal(int64(1)))Expect(tenant.Name).To(Equal("My Domain Inc."))Expect(tenant.Domain).To(Equal("mydomain.test.canhearyou.com"))Expect(err).To(BeNil())diff --git a/app/postgres/infra_test.go b/app/postgres/infra_test.goindex 3bc5e4c19..fa0d8f12c 100644--- a/app/postgres/infra_test.go+++ b/app/postgres/infra_test.go@@ -1,37 +1,18 @@package postgres_testimport (- "fmt""testing"- sqlmock "gopkg.in/DATA-DOG/go-sqlmock.v1"-"github.com/WeCanHearYou/wechy/app/postgres". "github.com/onsi/gomega")-func TestHealthCheckService_IsDatabaseOnline_Error(t *testing.T) {- RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()- mock.ExpectQuery("SELECT now()").WillReturnError(fmt.Errorf("some error"))-- svc := &postgres.HealthCheckService{DB: db}-- Expect(svc.IsDatabaseOnline()).To(BeFalse())- Expect(mock.ExpectationsWereMet()).ShouldNot(HaveOccurred())-}-func TestHealthCheckService_IsDatabaseOnline_Success(t *testing.T) {RegisterTestingT(t)-- db, mock, _ := sqlmock.New()- defer db.Close()- mock.ExpectQuery("SELECT now()").WillReturnRows(sqlmock.NewRows([]string{}))+ db := setup()+ defer teardown(db)svc := &postgres.HealthCheckService{DB: db}Expect(svc.IsDatabaseOnline()).To(BeTrue())- Expect(mock.ExpectationsWereMet()).ShouldNot(HaveOccurred())}diff --git a/app/postgres/setup_test.go b/app/postgres/setup_test.gonew file mode 100644index 000000000..c1a8c4d47--- /dev/null+++ b/app/postgres/setup_test.go@@ -0,0 +1,32 @@+package postgres_test++import (+ "database/sql"++ "github.com/WeCanHearYou/wechy/app/toolbox/env"+ _ "github.com/lib/pq"+)++func setup() *sql.DB {+ db, err := sql.Open("postgres", env.MustGet("DATABASE_URL"))+ if err != nil {+ panic(err)+ }+ return db+}++func teardown(db *sql.DB) {+ execute(db, "TRUNCATE TABLE users RESTART IDENTITY CASCADE")+ execute(db, "TRUNCATE TABLE tenants RESTART IDENTITY CASCADE")++ if db != nil {+ db.Close()+ }+}++func execute(db *sql.DB, command string, args ...interface{}) {+ _, err := db.Exec(command, args...)+ if err != nil {+ panic(err)+ }+}diff --git a/docker-compose.yml b/docker-compose.ymlindex 3880282fd..3430f93c3 100644--- a/docker-compose.yml+++ b/docker-compose.yml@@ -9,4 +9,12 @@ services:- "5555:5432"environment:POSTGRES_USER: wechy- POSTGRES_PASSWORD: wechy-pw\ No newline at end of file+ POSTGRES_PASSWORD: wechy-pw+ pgtest:+ restart: always+ image: postgres:9.6+ ports:+ - "5566:5432"+ environment:+ POSTGRES_USER: wechy_test+ POSTGRES_PASSWORD: wechy_test-pw\ No newline at end of filediff --git a/glide.lock b/glide.lockindex 9119cb376..dcf87beaa 100644--- a/glide.lock+++ b/glide.lock@@ -1,5 +1,5 @@-hash: 6ec0b6ecc8776f14df239492d1574d5c21fd7afa99279704f5b214cf462f1c9f-updated: 2017-03-22T23:03:27.872610802Z+hash: 8d8746a3ed9e22765aa09405f21add96e0d0669e343d36898b9aa4be02c41892+updated: 2017-03-26T12:47:45.673024907+01:00imports:- name: cloud.google.com/goversion: 890c17b428e8255915f506a9195b768df8a73dd0@@ -113,7 +113,5 @@ testImports:- matchers/support/goraph/node- matchers/support/goraph/util- types-- name: gopkg.in/DATA-DOG/go-sqlmock.v1- version: b983233bc0bbea4dc6e8ec8c8c923d935765ffec- name: gopkg.in/yaml.v2version: a3f3340b5840cee44f372bddb5880fcbc419b46adiff --git a/glide.yaml b/glide.yamlindex d8ccb4c82..7b6fcecfa 100644--- a/glide.yaml+++ b/glide.yaml@@ -17,4 +17,3 @@ import:testImport:- package: github.com/onsi/gomega-- package: gopkg.in/DATA-DOG/go-sqlmock.v1diff --git a/main.go b/main.goindex 269dd24b3..bd292f55b 100644--- a/main.go+++ b/main.go@@ -18,10 +18,6 @@ var buildtime stringvar version = "0.0.0"func migrate() {- if env.IsTest() {- return- }-fmt.Printf("Running migrations... \n")errors, ok := mig.UpSync(env.MustGet("DATABASE_URL"), "./migrations")if !ok {diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.gitignore b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.gitignoredeleted file mode 100644index e4001c081..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.gitignore+++ /dev/null@@ -1,3 +0,0 @@-/examples/blog/blog-/examples/orders/orders-/examples/basic/basicdiff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.travis.yml b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.travis.ymldeleted file mode 100644index 211edd73c..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.travis.yml+++ /dev/null@@ -1,16 +0,0 @@-language: go--go:- - 1.2- - 1.3- - 1.4- - 1.5- - 1.6- - 1.7- - 1.8- - tip--script: go test -race -coverprofile=coverage.txt -covermode=atomic--after_success:- - bash <(curl -s https://codecov.io/bash)diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/LICENSE b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/LICENSEdeleted file mode 100644index 7f8bedf4d..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/LICENSE+++ /dev/null@@ -1,28 +0,0 @@-The three clause BSD license (http://en.wikipedia.org/wiki/BSD_licenses)--Copyright (c) 2013-2017, DATA-DOG team-All rights reserved.--Redistribution and use in source and binary forms, with or without-modification, are permitted provided that the following conditions are met:--* Redistributions of source code must retain the above copyright notice, this- list of conditions and the following disclaimer.--* Redistributions in binary form must reproduce the above copyright notice,- this list of conditions and the following disclaimer in the documentation- and/or other materials provided with the distribution.--* The name DataDog.lt may not be used to endorse or promote products- derived from this software without specific prior written permission.--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE-DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT,-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,-EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/README.md b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/README.mddeleted file mode 100644index f3d54873a..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/README.md+++ /dev/null@@ -1,223 +0,0 @@-[](https://travis-ci.org/DATA-DOG/go-sqlmock)-[](https://godoc.org/github.com/DATA-DOG/go-sqlmock)-[](https://codecov.io/github/DATA-DOG/go-sqlmock)--# Sql driver mock for Golang--**sqlmock** is a mock library implementing [sql/driver](https://godoc.org/database/sql/driver). Which has one and only-purpose - to simulate any **sql** driver behavior in tests, without needing a real database connection. It helps to-maintain correct **TDD** workflow.--- this library is now complete and stable. (you may not find new changes for this reason)-- 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.--## Install-- go get gopkg.in/DATA-DOG/go-sqlmock.v1--## Documentation and Examples--Visit [godoc](http://godoc.org/github.com/DATA-DOG/go-sqlmock) for general examples and public api reference.-See **.travis.yml** for supported **go** versions.-Different use case, is to functionally test with a real database - [go-txdb](https://github.com/DATA-DOG/go-txdb)-all database related actions are isolated within a single transaction so the database can remain in the same state.--See implementation examples:--- [blog API server](https://github.com/DATA-DOG/go-sqlmock/tree/master/examples/blog)-- [the same orders example](https://github.com/DATA-DOG/go-sqlmock/tree/master/examples/orders)--### Something you may want to test--``` go-package main--import "database/sql"--func recordStats(db *sql.DB, userID, productID int64) (err error) {- tx, err := db.Begin()- if err != nil {- return- }-- defer func() {- switch err {- case nil:- err = tx.Commit()- default:- tx.Rollback()- }- }()-- if _, err = tx.Exec("UPDATE products SET views = views + 1"); err != nil {- return- }- if _, err = tx.Exec("INSERT INTO product_viewers (user_id, product_id) VALUES (?, ?)", userID, productID); err != nil {- return- }- return-}--func main() {- // @NOTE: the real connection is not required for tests- db, err := sql.Open("mysql", "root@/blog")- if err != nil {- panic(err)- }- defer db.Close()-- if err = recordStats(db, 1 /*some user id*/, 5 /*some product id*/); err != nil {- panic(err)- }-}-```--### Tests with sqlmock--``` go-package main--import (- "fmt"- "testing"-- "gopkg.in/DATA-DOG/go-sqlmock.v1"-)--// a successful case-func TestShouldUpdateStats(t *testing.T) {- db, mock, err := sqlmock.New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- mock.ExpectBegin()- mock.ExpectExec("UPDATE products").WillReturnResult(sqlmock.NewResult(1, 1))- mock.ExpectExec("INSERT INTO product_viewers").WithArgs(2, 3).WillReturnResult(sqlmock.NewResult(1, 1))- mock.ExpectCommit()-- // now we execute our method- if err = recordStats(db, 2, 3); err != nil {- t.Errorf("error was not expected while updating stats: %s", err)- }-- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--// a failing test case-func TestShouldRollbackStatUpdatesOnFailure(t *testing.T) {- db, mock, err := sqlmock.New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- mock.ExpectBegin()- mock.ExpectExec("UPDATE products").WillReturnResult(sqlmock.NewResult(1, 1))- mock.ExpectExec("INSERT INTO product_viewers").- WithArgs(2, 3).- WillReturnError(fmt.Errorf("some error"))- mock.ExpectRollback()-- // now we execute our method- if err = recordStats(db, 2, 3); err == nil {- t.Errorf("was expecting an error, but there was none")- }-- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}-```--## 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-- go test -race--## Change Log--- **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.-- **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-interface methods, see [issue](https://github.com/DATA-DOG/go-sqlmock/issues/5)-- **2014-05-29** allow to match arguments in more sophisticated ways, by providing an **sqlmock.Argument** interface-- **2014-04-21** introduce **sqlmock.New()** to open a mock database connection for tests. This method-calls sql.DB.Ping to ensure that connection is open, see [issue](https://github.com/DATA-DOG/go-sqlmock/issues/4).-This way on Close it will surely assert if all expectations are met, even if database was not triggered at all.-The old way is still available, but it is advisable to call db.Ping manually before asserting with db.Close.-- **2014-02-14** RowsFromCSVString is now a part of Rows interface named as FromCSVString.-It has changed to allow more ways to construct rows and to easily extend this API in future.-See [issue 1](https://github.com/DATA-DOG/go-sqlmock/issues/1)-**RowsFromCSVString** is deprecated and will be removed in future--## Contributions--Feel free to open a pull request. Note, if you wish to contribute an extension to public (exported methods or types) --please open an issue before, to discuss whether these changes can be accepted. All backward incompatible changes are-and will be treated cautiously--## License--The [three clause BSD license](http://en.wikipedia.org/wiki/BSD_licenses)-diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/argument.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/argument.godeleted file mode 100644index 7727481a8..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/argument.go+++ /dev/null@@ -1,24 +0,0 @@-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-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/argument_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/argument_test.godeleted file mode 100644index 3088ed470..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/argument_test.go+++ /dev/null@@ -1,58 +0,0 @@-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)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/driver.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/driver.godeleted file mode 100644index 2a480fee6..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/driver.go+++ /dev/null@@ -1,78 +0,0 @@-package sqlmock--import (- "database/sql"- "database/sql/driver"- "fmt"- "sync"-)--var pool *mockDriver--func init() {- pool = &mockDriver{- conns: make(map[string]*sqlmock),- }- sql.Register("sqlmock", pool)-}--type mockDriver struct {- sync.Mutex- counter int- conns map[string]*sqlmock-}--func (d *mockDriver) Open(dsn string) (driver.Conn, error) {- d.Lock()- defer d.Unlock()-- c, ok := d.conns[dsn]- if !ok {- return c, fmt.Errorf("expected a connection to be available, but it is not")- }-- c.opened++- return c, nil-}--// New creates sqlmock database connection-// and a mock to manage expectations.-// Pings db so that all expectations could be-// asserted.-func New() (*sql.DB, Sqlmock, error) {- pool.Lock()- dsn := fmt.Sprintf("sqlmock_db_%d", pool.counter)- pool.counter++-- smock := &sqlmock{dsn: dsn, drv: pool, ordered: true}- pool.conns[dsn] = smock- pool.Unlock()-- return smock.open()-}--// 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)- }- smock := &sqlmock{dsn: dsn, drv: pool, ordered: true}- pool.conns[dsn] = smock- pool.Unlock()-- return smock.open()-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/driver_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/driver_test.godeleted file mode 100644index 1a65c1cae..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/driver_test.go+++ /dev/null@@ -1,112 +0,0 @@-package sqlmock--import (- "fmt"- "testing"-)--type void struct{}--func (void) Print(...interface{}) {}--func ExampleNew() {- db, mock, err := New()- if err != nil {- fmt.Println("expected no error, but got:", err)- return- }- defer db.Close()- // now we can expect operations performed on db- mock.ExpectBegin().WillReturnError(fmt.Errorf("an error will occur on db.Begin() call"))-}--func TestShouldOpenConnectionIssue15(t *testing.T) {- db, mock, err := New()- if err != nil {- t.Errorf("expected no error, but got: %s", err)- }- if len(pool.conns) != 1 {- t.Errorf("expected 1 connection in pool, but there is: %d", len(pool.conns))- }-- smock, _ := mock.(*sqlmock)- if smock.opened != 1 {- t.Errorf("expected 1 connection on mock to be opened, but there is: %d", smock.opened)- }-- // defer so the rows gets closed first- defer func() {- if smock.opened != 0 {- t.Errorf("expected no connections on mock to be opened, but there is: %d", smock.opened)- }- }()-- mock.ExpectQuery("SELECT").WillReturnRows(NewRows([]string{"one", "two"}).AddRow("val1", "val2"))- rows, err := db.Query("SELECT")- if err != nil {- t.Errorf("unexpected error: %s", err)- }- defer rows.Close()-- mock.ExpectExec("UPDATE").WillReturnResult(NewResult(1, 1))- if _, err = db.Exec("UPDATE"); err != nil {- t.Errorf("unexpected error: %s", err)- }-- // now there should be two connections open- if smock.opened != 2 {- t.Errorf("expected 2 connection on mock to be opened, but there is: %d", smock.opened)- }-- mock.ExpectClose()- if err = db.Close(); err != nil {- t.Errorf("expected no error on close, but got: %s", err)- }-- // one is still reserved for rows- if smock.opened != 1 {- t.Errorf("expected 1 connection on mock to be still reserved for rows, but there is: %d", smock.opened)- }-}--func TestTwoOpenConnectionsOnTheSameDSN(t *testing.T) {- db, mock, err := New()- if err != nil {- t.Errorf("expected no error, but got: %s", err)- }- db2, mock2, err := New()- if err != nil {- t.Errorf("expected no error, but got: %s", err)- }- if len(pool.conns) != 2 {- t.Errorf("expected 2 connection in pool, but there is: %d", len(pool.conns))- }-- if db == db2 {- t.Errorf("expected not the same database instance, but it is the same")- }- if mock == mock2 {- 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")- }-}\ No newline at end of filediff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/basic/basic.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/basic/basic.godeleted file mode 100644index 0fbf98d7d..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/basic/basic.go+++ /dev/null@@ -1,40 +0,0 @@-package main--import "database/sql"--func recordStats(db *sql.DB, userID, productID int64) (err error) {- tx, err := db.Begin()- if err != nil {- return- }-- defer func() {- switch err {- case nil:- err = tx.Commit()- default:- tx.Rollback()- }- }()-- if _, err = tx.Exec("UPDATE products SET views = views + 1"); err != nil {- return- }- if _, err = tx.Exec("INSERT INTO product_viewers (user_id, product_id) VALUES (?, ?)", userID, productID); err != nil {- return- }- return-}--func main() {- // @NOTE: the real connection is not required for tests- db, err := sql.Open("mysql", "root@/blog")- if err != nil {- panic(err)- }- defer db.Close()-- if err = recordStats(db, 1 /*some user id*/, 5 /*some product id*/); err != nil {- panic(err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/basic/basic_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/basic/basic_test.godeleted file mode 100644index 0825f90dd..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/basic/basic_test.go+++ /dev/null@@ -1,58 +0,0 @@-package main--import (- "fmt"- "testing"-- "github.com/DATA-DOG/go-sqlmock"-)--// a successful case-func TestShouldUpdateStats(t *testing.T) {- db, mock, err := sqlmock.New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- mock.ExpectBegin()- mock.ExpectExec("UPDATE products").WillReturnResult(sqlmock.NewResult(1, 1))- mock.ExpectExec("INSERT INTO product_viewers").WithArgs(2, 3).WillReturnResult(sqlmock.NewResult(1, 1))- mock.ExpectCommit()-- // now we execute our method- if err = recordStats(db, 2, 3); err != nil {- t.Errorf("error was not expected while updating stats: %s", err)- }-- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--// a failing test case-func TestShouldRollbackStatUpdatesOnFailure(t *testing.T) {- db, mock, err := sqlmock.New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- mock.ExpectBegin()- mock.ExpectExec("UPDATE products").WillReturnResult(sqlmock.NewResult(1, 1))- mock.ExpectExec("INSERT INTO product_viewers").- WithArgs(2, 3).- WillReturnError(fmt.Errorf("some error"))- mock.ExpectRollback()-- // now we execute our method- if err = recordStats(db, 2, 3); err == nil {- t.Errorf("was expecting an error, but there was none")- }-- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/blog/blog.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/blog/blog.godeleted file mode 100644index c4aec06c5..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/blog/blog.go+++ /dev/null@@ -1,81 +0,0 @@-package main--import (- "database/sql"- "encoding/json"- "net/http"-)--type api struct {- db *sql.DB-}--type post struct {- ID int- Title string- Body string-}--func (a *api) posts(w http.ResponseWriter, r *http.Request) {- rows, err := a.db.Query("SELECT id, title, body FROM posts")- if err != nil {- a.fail(w, "failed to fetch posts: "+err.Error(), 500)- return- }- defer rows.Close()-- var posts []*post- for rows.Next() {- p := &post{}- if err := rows.Scan(&p.ID, &p.Title, &p.Body); err != nil {- a.fail(w, "failed to scan post: "+err.Error(), 500)- return- }- posts = append(posts, p)- }- if rows.Err() != nil {- a.fail(w, "failed to read all posts: "+rows.Err().Error(), 500)- return- }-- data := struct {- Posts []*post- }{posts}-- a.ok(w, data)-}--func main() {- // @NOTE: the real connection is not required for tests- db, err := sql.Open("mysql", "root@/blog")- if err != nil {- panic(err)- }- app := &api{db: db}- http.HandleFunc("/posts", app.posts)- http.ListenAndServe(":8080", nil)-}--func (a *api) fail(w http.ResponseWriter, msg string, status int) {- w.Header().Set("Content-Type", "application/json")-- data := struct {- Error string- }{Error: msg}-- resp, _ := json.Marshal(data)- w.WriteHeader(status)- w.Write(resp)-}--func (a *api) ok(w http.ResponseWriter, data interface{}) {- w.Header().Set("Content-Type", "application/json")-- resp, err := json.Marshal(data)- if err != nil {- w.WriteHeader(http.StatusInternalServerError)- a.fail(w, "oops something evil has happened", 500)- return- }- w.Write(resp)-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/blog/blog_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/blog/blog_test.godeleted file mode 100644index aa1881a57..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/blog/blog_test.go+++ /dev/null@@ -1,102 +0,0 @@-package main--import (- "bytes"- "encoding/json"- "fmt"- "net/http"- "net/http/httptest"- "testing"-- "github.com/DATA-DOG/go-sqlmock"-)--func (a *api) assertJSON(actual []byte, data interface{}, t *testing.T) {- expected, err := json.Marshal(data)- if err != nil {- t.Fatalf("an error '%s' was not expected when marshaling expected json data", err)- }-- if bytes.Compare(expected, actual) != 0 {- t.Errorf("the expected json: %s is different from actual %s", expected, actual)- }-}--func TestShouldGetPosts(t *testing.T) {- db, mock, err := sqlmock.New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- // create app with mocked db, request and response to test- app := &api{db}- req, err := http.NewRequest("GET", "http://localhost/posts", nil)- if err != nil {- t.Fatalf("an error '%s' was not expected while creating request", err)- }- w := httptest.NewRecorder()-- // before we actually execute our api function, we need to expect required DB actions- rows := sqlmock.NewRows([]string{"id", "title", "body"}).- AddRow(1, "post 1", "hello").- AddRow(2, "post 2", "world")-- mock.ExpectQuery("^SELECT (.+) FROM posts$").WillReturnRows(rows)-- // now we execute our request- app.posts(w, req)-- if w.Code != 200 {- t.Fatalf("expected status code to be 200, but got: %d", w.Code)- }-- data := struct {- Posts []*post- }{Posts: []*post{- {ID: 1, Title: "post 1", Body: "hello"},- {ID: 2, Title: "post 2", Body: "world"},- }}- app.assertJSON(w.Body.Bytes(), data, t)-- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestShouldRespondWithErrorOnFailure(t *testing.T) {- db, mock, err := sqlmock.New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- // create app with mocked db, request and response to test- app := &api{db}- req, err := http.NewRequest("GET", "http://localhost/posts", nil)- if err != nil {- t.Fatalf("an error '%s' was not expected while creating request", err)- }- w := httptest.NewRecorder()-- // before we actually execute our api function, we need to expect required DB actions- mock.ExpectQuery("^SELECT (.+) FROM posts$").WillReturnError(fmt.Errorf("some error"))-- // now we execute our request- app.posts(w, req)-- if w.Code != 500 {- t.Fatalf("expected status code to be 500, but got: %d", w.Code)- }-- data := struct {- Error string- }{"failed to fetch posts: some error"}- app.assertJSON(w.Body.Bytes(), data, t)-- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/doc.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/doc.godeleted file mode 100644index c7842af75..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/doc.go+++ /dev/null@@ -1 +0,0 @@-package examplesdiff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/orders/orders.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/orders/orders.godeleted file mode 100644index fb7e47e90..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/orders/orders.go+++ /dev/null@@ -1,121 +0,0 @@-package main--import (- "database/sql"- "fmt"- "log"-- "github.com/kisielk/sqlstruct"-)--const ORDER_PENDING = 0-const ORDER_CANCELLED = 1--type User struct {- Id int `sql:"id"`- Username string `sql:"username"`- Balance float64 `sql:"balance"`-}--type Order struct {- Id int `sql:"id"`- Value float64 `sql:"value"`- ReservedFee float64 `sql:"reserved_fee"`- Status int `sql:"status"`-}--func cancelOrder(id int, db *sql.DB) (err error) {- tx, err := db.Begin()- if err != nil {- return- }-- var order Order- var user User- sql := fmt.Sprintf(`-SELECT %s, %s-FROM orders AS o-INNER JOIN users AS u ON o.buyer_id = u.id-WHERE o.id = ?-FOR UPDATE`,- sqlstruct.ColumnsAliased(order, "o"),- sqlstruct.ColumnsAliased(user, "u"))-- // fetch order to cancel- rows, err := tx.Query(sql, id)- if err != nil {- tx.Rollback()- return- }-- defer rows.Close()- // no rows, nothing to do- if !rows.Next() {- tx.Rollback()- return- }-- // read order- err = sqlstruct.ScanAliased(&order, rows, "o")- if err != nil {- tx.Rollback()- return- }-- // ensure order status- if order.Status != ORDER_PENDING {- tx.Rollback()- return- }-- // read user- err = sqlstruct.ScanAliased(&user, rows, "u")- if err != nil {- tx.Rollback()- return- }- rows.Close() // manually close before other prepared statements-- // refund order value- sql = "UPDATE users SET balance = balance + ? WHERE id = ?"- refundStmt, err := tx.Prepare(sql)- if err != nil {- tx.Rollback()- return- }- defer refundStmt.Close()- _, err = refundStmt.Exec(order.Value+order.ReservedFee, user.Id)- if err != nil {- tx.Rollback()- return- }-- // update order status- order.Status = ORDER_CANCELLED- sql = "UPDATE orders SET status = ?, updated = NOW() WHERE id = ?"- orderUpdStmt, err := tx.Prepare(sql)- if err != nil {- tx.Rollback()- return- }- defer orderUpdStmt.Close()- _, err = orderUpdStmt.Exec(order.Status, order.Id)- if err != nil {- tx.Rollback()- return- }- return tx.Commit()-}--func main() {- // @NOTE: the real connection is not required for tests- db, err := sql.Open("mysql", "root:@/orders")- if err != nil {- log.Fatal(err)- }- defer db.Close()- err = cancelOrder(1, db)- if err != nil {- log.Fatal(err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/orders/orders_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/orders/orders_test.godeleted file mode 100644index 7562b8f5c..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/orders/orders_test.go+++ /dev/null@@ -1,108 +0,0 @@-package main--import (- "fmt"- "testing"-- "github.com/DATA-DOG/go-sqlmock"-)--// will test that order with a different status, cannot be cancelled-func TestShouldNotCancelOrderWithNonPendingStatus(t *testing.T) {- // open database stub- db, mock, err := sqlmock.New()- if err != nil {- t.Errorf("An error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- // columns are prefixed with "o" since we used sqlstruct to generate them- columns := []string{"o_id", "o_status"}- // expect transaction begin- mock.ExpectBegin()- // expect query to fetch order and user, match it with regexp- mock.ExpectQuery("SELECT (.+) FROM orders AS o INNER JOIN users AS u (.+) FOR UPDATE").- WithArgs(1).- WillReturnRows(sqlmock.NewRows(columns).FromCSVString("1,1"))- // expect transaction rollback, since order status is "cancelled"- mock.ExpectRollback()-- // run the cancel order function- err = cancelOrder(1, db)- if err != nil {- t.Errorf("Expected no error, but got %s instead", err)- }- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--// will test order cancellation-func TestShouldRefundUserWhenOrderIsCancelled(t *testing.T) {- // open database stub- db, mock, err := sqlmock.New()- if err != nil {- t.Errorf("An error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- // columns are prefixed with "o" since we used sqlstruct to generate them- columns := []string{"o_id", "o_status", "o_value", "o_reserved_fee", "u_id", "u_balance"}- // expect transaction begin- mock.ExpectBegin()- // expect query to fetch order and user, match it with regexp- mock.ExpectQuery("SELECT (.+) FROM orders AS o INNER JOIN users AS u (.+) FOR UPDATE").- WithArgs(1).- WillReturnRows(sqlmock.NewRows(columns).AddRow(1, 0, 25.75, 3.25, 2, 10.00))- // expect user balance update- mock.ExpectPrepare("UPDATE users SET balance").ExpectExec().- WithArgs(25.75+3.25, 2). // refund amount, user id- WillReturnResult(sqlmock.NewResult(0, 1)) // no insert id, 1 affected row- // expect order status update- mock.ExpectPrepare("UPDATE orders SET status").ExpectExec().- WithArgs(ORDER_CANCELLED, 1). // status, id- WillReturnResult(sqlmock.NewResult(0, 1)) // no insert id, 1 affected row- // expect a transaction commit- mock.ExpectCommit()-- // run the cancel order function- err = cancelOrder(1, db)- if err != nil {- t.Errorf("Expected no error, but got %s instead", err)- }- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--// will test order cancellation-func TestShouldRollbackOnError(t *testing.T) {- // open database stub- db, mock, err := sqlmock.New()- if err != nil {- t.Errorf("An error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- // expect transaction begin- mock.ExpectBegin()- // expect query to fetch order and user, match it with regexp- mock.ExpectQuery("SELECT (.+) FROM orders AS o INNER JOIN users AS u (.+) FOR UPDATE").- WithArgs(1).- WillReturnError(fmt.Errorf("Some error"))- // should rollback since error was returned from query execution- mock.ExpectRollback()-- // run the cancel order function- err = cancelOrder(1, db)- // error should return back- if err == nil {- t.Error("Expected error, but got none")- }- // we make sure that all expectations were met- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations.godeleted file mode 100644index 415759eb1..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations.go+++ /dev/null@@ -1,344 +0,0 @@-package sqlmock--import (- "database/sql/driver"- "fmt"- "regexp"- "strings"- "sync"- "time"-)--// an expectation interface-type expectation interface {- fulfilled() bool- Lock()- Unlock()- String() string-}--// common expectation struct-// satisfies the expectation interface-type commonExpectation struct {- sync.Mutex- triggered bool- err error-}--func (e *commonExpectation) fulfilled() bool {- return e.triggered-}--// ExpectedClose is used to manage *sql.DB.Close expectation-// returned by *Sqlmock.ExpectClose.-type ExpectedClose struct {- commonExpectation-}--// WillReturnError allows to set an error for *sql.DB.Close action-func (e *ExpectedClose) WillReturnError(err error) *ExpectedClose {- e.err = err- return e-}--// String returns string representation-func (e *ExpectedClose) String() string {- msg := "ExpectedClose => expecting database Close"- if e.err != nil {- msg += fmt.Sprintf(", which should return error: %s", e.err)- }- return msg-}--// ExpectedBegin is used to manage *sql.DB.Begin expectation-// returned by *Sqlmock.ExpectBegin.-type ExpectedBegin struct {- commonExpectation- delay time.Duration-}--// WillReturnError allows to set an error for *sql.DB.Begin action-func (e *ExpectedBegin) WillReturnError(err error) *ExpectedBegin {- e.err = err- return e-}--// String returns string representation-func (e *ExpectedBegin) String() string {- msg := "ExpectedBegin => expecting database transaction Begin"- if e.err != nil {- msg += fmt.Sprintf(", which should return error: %s", e.err)- }- 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-// returned by *Sqlmock.ExpectCommit.-type ExpectedCommit struct {- commonExpectation-}--// WillReturnError allows to set an error for *sql.Tx.Close action-func (e *ExpectedCommit) WillReturnError(err error) *ExpectedCommit {- e.err = err- return e-}--// String returns string representation-func (e *ExpectedCommit) String() string {- msg := "ExpectedCommit => expecting transaction Commit"- if e.err != nil {- msg += fmt.Sprintf(", which should return error: %s", e.err)- }- return msg-}--// ExpectedRollback is used to manage *sql.Tx.Rollback expectation-// returned by *Sqlmock.ExpectRollback.-type ExpectedRollback struct {- commonExpectation-}--// WillReturnError allows to set an error for *sql.Tx.Rollback action-func (e *ExpectedRollback) WillReturnError(err error) *ExpectedRollback {- e.err = err- return e-}--// String returns string representation-func (e *ExpectedRollback) String() string {- msg := "ExpectedRollback => expecting transaction Rollback"- if e.err != nil {- msg += fmt.Sprintf(", which should return error: %s", e.err)- }- return msg-}--// ExpectedQuery is used to manage *sql.DB.Query, *dql.DB.QueryRow, *sql.Tx.Query,-// *sql.Tx.QueryRow, *sql.Stmt.Query or *sql.Stmt.QueryRow expectations.-// Returned by *Sqlmock.ExpectQuery.-type ExpectedQuery struct {- queryBasedExpectation- rows driver.Rows- delay time.Duration-}--// WithArgs will match given expected args to actual database query arguments.-// if at least one argument does not match, it will return an error. For specific-// arguments an sqlmock.Argument interface can be used to match an argument.-func (e *ExpectedQuery) WithArgs(args ...driver.Value) *ExpectedQuery {- e.args = args- return e-}--// WillReturnError allows to set an error for expected database query-func (e *ExpectedQuery) WillReturnError(err error) *ExpectedQuery {- e.err = err- return e-}--// WillDelayFor allows to specify duration for which it will delay-// result. May be used together with Context-func (e *ExpectedQuery) WillDelayFor(duration time.Duration) *ExpectedQuery {- e.delay = duration- return e-}--// String returns string representation-func (e *ExpectedQuery) String() string {- msg := "ExpectedQuery => expecting Query or QueryRow which:"- msg += "\n - matches sql: '" + e.sqlRegex.String() + "'"-- if len(e.args) == 0 {- msg += "\n - is without arguments"- } else {- msg += "\n - is with arguments:\n"- for i, arg := range e.args {- msg += fmt.Sprintf(" %d - %+v\n", i, arg)- }- msg = strings.TrimSpace(msg)- }-- if e.rows != nil {- msg += fmt.Sprintf("\n - %s", e.rows)- }-- if e.err != nil {- msg += fmt.Sprintf("\n - should return error: %s", e.err)- }-- return msg-}--// ExpectedExec is used to manage *sql.DB.Exec, *sql.Tx.Exec or *sql.Stmt.Exec expectations.-// Returned by *Sqlmock.ExpectExec.-type ExpectedExec struct {- queryBasedExpectation- result driver.Result- delay time.Duration-}--// WithArgs will match given expected args to actual database exec operation arguments.-// if at least one argument does not match, it will return an error. For specific-// arguments an sqlmock.Argument interface can be used to match an argument.-func (e *ExpectedExec) WithArgs(args ...driver.Value) *ExpectedExec {- e.args = args- return e-}--// WillReturnError allows to set an error for expected database exec action-func (e *ExpectedExec) WillReturnError(err error) *ExpectedExec {- e.err = err- 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-func (e *ExpectedExec) String() string {- msg := "ExpectedExec => expecting Exec which:"- msg += "\n - matches sql: '" + e.sqlRegex.String() + "'"-- if len(e.args) == 0 {- msg += "\n - is without arguments"- } else {- msg += "\n - is with arguments:\n"- var margs []string- for i, arg := range e.args {- margs = append(margs, fmt.Sprintf(" %d - %+v", i, arg))- }- msg += strings.Join(margs, "\n")- }-- if e.result != nil {- res, _ := e.result.(*result)- msg += "\n - should return Result having:"- msg += fmt.Sprintf("\n LastInsertId: %d", res.insertID)- msg += fmt.Sprintf("\n RowsAffected: %d", res.rowsAffected)- if res.err != nil {- msg += fmt.Sprintf("\n Error: %s", res.err)- }- }-- if e.err != nil {- msg += fmt.Sprintf("\n - should return error: %s", e.err)- }-- return msg-}--// WillReturnResult arranges for an expected Exec() to return a particular-// result, there is sqlmock.NewResult(lastInsertID int64, affectedRows int64) method-// to build a corresponding result. Or if actions needs to be tested against errors-// sqlmock.NewErrorResult(err error) to return a given error.-func (e *ExpectedExec) WillReturnResult(result driver.Result) *ExpectedExec {- e.result = result- return e-}--// ExpectedPrepare is used to manage *sql.DB.Prepare or *sql.Tx.Prepare expectations.-// Returned by *Sqlmock.ExpectPrepare.-type ExpectedPrepare struct {- commonExpectation- mock *sqlmock- sqlRegex *regexp.Regexp- statement driver.Stmt- closeErr error- delay time.Duration-}--// WillReturnError allows to set an error for the expected *sql.DB.Prepare or *sql.Tx.Prepare action.-func (e *ExpectedPrepare) WillReturnError(err error) *ExpectedPrepare {- e.err = err- return e-}--// WillReturnCloseError allows to set an error for this prapared statement Close action-func (e *ExpectedPrepare) WillReturnCloseError(err error) *ExpectedPrepare {- e.closeErr = err- 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-}--// ExpectQuery allows to expect Query() or QueryRow() on this prepared statement.-// this method is convenient in order to prevent duplicating sql query string matching.-func (e *ExpectedPrepare) ExpectQuery() *ExpectedQuery {- eq := &ExpectedQuery{}- eq.sqlRegex = e.sqlRegex- e.mock.expected = append(e.mock.expected, eq)- return eq-}--// ExpectExec allows to expect Exec() on this prepared statement.-// this method is convenient in order to prevent duplicating sql query string matching.-func (e *ExpectedPrepare) ExpectExec() *ExpectedExec {- eq := &ExpectedExec{}- eq.sqlRegex = e.sqlRegex- e.mock.expected = append(e.mock.expected, eq)- return eq-}--// String returns string representation-func (e *ExpectedPrepare) String() string {- msg := "ExpectedPrepare => expecting Prepare statement which:"- msg += "\n - matches sql: '" + e.sqlRegex.String() + "'"-- if e.err != nil {- msg += fmt.Sprintf("\n - should return error: %s", e.err)- }-- if e.closeErr != nil {- msg += fmt.Sprintf("\n - should return error on Close: %s", e.closeErr)- }-- return msg-}--// query based expectation-// adds a query matching logic-type queryBasedExpectation struct {- commonExpectation- sqlRegex *regexp.Regexp- args []driver.Value-}--func (e *queryBasedExpectation) attemptMatch(sql string, args []namedValue) (err error) {- if !e.queryMatches(sql) {- return fmt.Errorf(`could not match sql: "%s" with expected regexp "%s"`, sql, e.sqlRegex.String())- }-- // catch panic- defer func() {- if e := recover(); e != nil {- _, ok := e.(error)- if !ok {- err = fmt.Errorf(e.(string))- }- }- }()-- err = e.argsMatches(args)- return-}--func (e *queryBasedExpectation) queryMatches(sql string) bool {- return e.sqlRegex.MatchString(sql)-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_before_go18.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_before_go18.godeleted file mode 100644index 146f24047..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_before_go18.go+++ /dev/null@@ -1,52 +0,0 @@-// +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-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_go18.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_go18.godeleted file mode 100644index 2b4b44e9f..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_go18.go+++ /dev/null@@ -1,66 +0,0 @@-// +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 {- 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))- }- // @TODO should we assert either all args are named or ordinal?- for k, v := range args {- // custom argument matcher- matcher, ok := e.args[k].(Argument)- if ok {- 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]- if named, isNamed := dval.(sql.NamedArg); isNamed {- dval = named.Value- if v.Name != named.Name {- return fmt.Errorf("named argument %d: name: \"%s\" does not match expected: \"%s\"", k, v.Name, named.Name)- }- } else if k+1 != v.Ordinal {- return fmt.Errorf("argument %d: ordinal position: %d does not match expected: %d", k, k+1, v.Ordinal)- }-- // 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-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_go18_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_go18_test.godeleted file mode 100644index 5f30d2ff1..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_go18_test.go+++ /dev/null@@ -1,64 +0,0 @@-// +build go1.8--package sqlmock--import (- "database/sql"- "database/sql/driver"- "testing"-)--func TestQueryExpectationNamedArgComparison(t *testing.T) {- e := &queryBasedExpectation{}- against := []namedValue{{Value: int64(5), Name: "id"}}- if err := e.argsMatches(against); err != nil {- t.Errorf("arguments should match, since the no expectation was set, but got err: %s", err)- }-- e.args = []driver.Value{- sql.Named("id", 5),- sql.Named("s", "str"),- }-- if err := e.argsMatches(against); err == nil {- t.Error("arguments should not match, since the size is not the same")- }-- against = []namedValue{- {Value: int64(5), Name: "id"},- {Value: "str", Name: "s"},- }-- if err := e.argsMatches(against); err != nil {- t.Errorf("arguments should have matched, but it did not: %v", err)- }-- against = []namedValue{- {Value: int64(5), Name: "id"},- {Value: "str", Name: "username"},- }-- if err := e.argsMatches(against); err == nil {- t.Error("arguments matched, but it should have not due to Name")- }-- e.args = []driver.Value{int64(5), "str"}-- against = []namedValue{- {Value: int64(5), Ordinal: 0},- {Value: "str", Ordinal: 1},- }-- if err := e.argsMatches(against); err == nil {- t.Error("arguments matched, but it should have not due to wrong Ordinal position")- }-- against = []namedValue{- {Value: int64(5), Ordinal: 1},- {Value: "str", Ordinal: 2},- }-- if err := e.argsMatches(against); err != nil {- t.Errorf("arguments should have matched, but it did not: %v", err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_test.godeleted file mode 100644index 2e3c097b0..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/expectations_test.go+++ /dev/null@@ -1,154 +0,0 @@-package sqlmock--import (- "database/sql/driver"- "fmt"- "regexp"- "testing"- "time"-)--func TestQueryExpectationArgComparison(t *testing.T) {- e := &queryBasedExpectation{}- against := []namedValue{{Value: int64(5), Ordinal: 1}}- if err := e.argsMatches(against); err != nil {- t.Errorf("arguments should match, since the no expectation was set, but got err: %s", err)- }-- e.args = []driver.Value{5, "str"}-- against = []namedValue{{Value: int64(5), Ordinal: 1}}- if err := e.argsMatches(against); err == nil {- t.Error("arguments should not match, since the size is not the same")- }-- against = []namedValue{- {Value: int64(3), Ordinal: 1},- {Value: "str", Ordinal: 2},- }- if err := e.argsMatches(against); err == nil {- t.Error("arguments should not match, since the first argument (int value) is different")- }-- against = []namedValue{- {Value: int64(5), Ordinal: 1},- {Value: "st", Ordinal: 2},- }- if err := e.argsMatches(against); err == nil {- t.Error("arguments should not match, since the second argument (string value) is different")- }-- against = []namedValue{- {Value: int64(5), Ordinal: 1},- {Value: "str", Ordinal: 2},- }- if err := e.argsMatches(against); err != nil {- t.Errorf("arguments should match, but it did not: %s", err)- }-- const longForm = "Jan 2, 2006 at 3:04pm (MST)"- tm, _ := time.Parse(longForm, "Feb 3, 2013 at 7:54pm (PST)")- e.args = []driver.Value{5, tm}-- against = []namedValue{- {Value: int64(5), Ordinal: 1},- {Value: tm, Ordinal: 2},- }- if err := e.argsMatches(against); err != nil {- t.Error("arguments should match, but it did not")- }-- e.args = []driver.Value{5, AnyArg()}- if err := e.argsMatches(against); err != nil {- t.Errorf("arguments should match, but it did not: %s", err)- }-}--func TestQueryExpectationArgComparisonBool(t *testing.T) {- var e *queryBasedExpectation-- e = &queryBasedExpectation{args: []driver.Value{true}}- against := []namedValue{- {Value: true, Ordinal: 1},- }- if err := e.argsMatches(against); err != nil {- t.Error("arguments should match, since arguments are the same")- }-- e = &queryBasedExpectation{args: []driver.Value{false}}- against = []namedValue{- {Value: false, Ordinal: 1},- }- if err := e.argsMatches(against); err != nil {- t.Error("arguments should match, since argument are the same")- }-- e = &queryBasedExpectation{args: []driver.Value{true}}- against = []namedValue{- {Value: false, Ordinal: 1},- }- if err := e.argsMatches(against); err == nil {- t.Error("arguments should not match, since argument is different")- }-- e = &queryBasedExpectation{args: []driver.Value{false}}- against = []namedValue{- {Value: true, Ordinal: 1},- }- if err := e.argsMatches(against); err == nil {- t.Error("arguments should not match, since argument is different")- }-}--func TestQueryExpectationSqlMatch(t *testing.T) {- e := &ExpectedExec{}-- e.sqlRegex = regexp.MustCompile("SELECT x FROM")- if !e.queryMatches("SELECT x FROM someting") {- t.Errorf("Sql must have matched the query")- }-- e.sqlRegex = regexp.MustCompile("SELECT COUNT\\(x\\) FROM")- if !e.queryMatches("SELECT COUNT(x) FROM someting") {- t.Errorf("Sql must have matched the query")- }-}--func ExampleExpectedExec() {- db, mock, _ := New()- result := NewErrorResult(fmt.Errorf("some error"))- mock.ExpectExec("^INSERT (.+)").WillReturnResult(result)- res, _ := db.Exec("INSERT something")- _, err := res.LastInsertId()- fmt.Println(err)- // Output: some error-}--func TestBuildQuery(t *testing.T) {- db, mock, _ := New()- query := `- SELECT- name,- email,- address,- anotherfield- FROM user- where- name = 'John'- and- address = 'Jakarta'-- `-- mock.ExpectQuery(query)- mock.ExpectExec(query)- mock.ExpectPrepare(query)-- db.QueryRow(query)- db.Exec(query)- db.Prepare(query)-- if err := mock.ExpectationsWereMet(); err != nil {- t.Error(err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/result.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/result.godeleted file mode 100644index a63e72ba8..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/result.go+++ /dev/null@@ -1,39 +0,0 @@-package sqlmock--import (- "database/sql/driver"-)--// Result satisfies sql driver Result, which-// holds last insert id and rows affected-// by Exec queries-type result struct {- insertID int64- rowsAffected int64- err error-}--// NewResult creates a new sql driver Result-// for Exec based query mocks.-func NewResult(lastInsertID int64, rowsAffected int64) driver.Result {- return &result{- insertID: lastInsertID,- rowsAffected: rowsAffected,- }-}--// NewErrorResult creates a new sql driver Result-// which returns an error given for both interface methods-func NewErrorResult(err error) driver.Result {- return &result{- err: err,- }-}--func (r *result) LastInsertId() (int64, error) {- return r.insertID, r.err-}--func (r *result) RowsAffected() (int64, error) {- return r.rowsAffected, r.err-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/result_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/result_test.godeleted file mode 100644index 08d47c9d2..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/result_test.go+++ /dev/null@@ -1,62 +0,0 @@-package sqlmock--import (- "fmt"- "testing"-)--// used for examples-var mock = &sqlmock{}--func ExampleNewErrorResult() {- db, mock, _ := New()- result := NewErrorResult(fmt.Errorf("some error"))- mock.ExpectExec("^INSERT (.+)").WillReturnResult(result)- res, _ := db.Exec("INSERT something")- _, err := res.LastInsertId()- fmt.Println(err)- // Output: some error-}--func ExampleNewResult() {- var lastInsertID, affected int64- result := NewResult(lastInsertID, affected)- mock.ExpectExec("^INSERT (.+)").WillReturnResult(result)- fmt.Println(mock.ExpectationsWereMet())- // Output: there is a remaining expectation which was not matched: ExpectedExec => expecting Exec which:- // - matches sql: '^INSERT (.+)'- // - is without arguments- // - should return Result having:- // LastInsertId: 0- // RowsAffected: 0-}--func TestShouldReturnValidSqlDriverResult(t *testing.T) {- result := NewResult(1, 2)- id, err := result.LastInsertId()- if 1 != id {- t.Errorf("Expected last insert id to be 1, but got: %d", id)- }- if err != nil {- t.Errorf("expected no error, but got: %s", err)- }- affected, err := result.RowsAffected()- if 2 != affected {- t.Errorf("Expected affected rows to be 2, but got: %d", affected)- }- if err != nil {- t.Errorf("expected no error, but got: %s", err)- }-}--func TestShouldReturnErroeSqlDriverResult(t *testing.T) {- result := NewErrorResult(fmt.Errorf("some error"))- _, err := result.LastInsertId()- if err == nil {- t.Error("expected error, but got none")- }- _, err = result.RowsAffected()- if err == nil {- t.Error("expected error, but got none")- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows.godeleted file mode 100644index 39f9f836c..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows.go+++ /dev/null@@ -1,144 +0,0 @@-package sqlmock--import (- "database/sql/driver"- "encoding/csv"- "fmt"- "io"- "strings"-)--// CSVColumnParser is a function which converts trimmed csv-// column string to a []byte representation. currently-// transforms NULL to nil-var CSVColumnParser = func(s string) []byte {- switch {- case strings.ToLower(s) == "null":- return nil- }- return []byte(s)-}--type rowSets struct {- sets []*Rows- pos int-}--func (rs *rowSets) Columns() []string {- return rs.sets[rs.pos].cols-}--func (rs *rowSets) Close() error {- return rs.sets[rs.pos].closeErr-}--// advances to next row-func (rs *rowSets) Next(dest []driver.Value) error {- r := rs.sets[rs.pos]- r.pos++- if r.pos > len(r.rows) {- return io.EOF // per interface spec- }-- for i, col := range r.rows[r.pos-1] {- dest[i] = col- }-- return r.nextErr[r.pos-1]-}--// transforms to debuggable printable string-func (rs *rowSets) String() string {- msg := "should return rows:\n"- if len(rs.sets) == 1 {- for n, row := range rs.sets[0].rows {- msg += fmt.Sprintf(" row %d - %+v\n", n, row)- }- return strings.TrimSpace(msg)- }- for i, set := range rs.sets {- msg += fmt.Sprintf(" result set: %d\n", i)- for n, row := range set.rows {- msg += fmt.Sprintf(" row %d - %+v\n", n, row)- }- }- return strings.TrimSpace(msg)-}--// Rows is a mocked collection of rows to-// return for Query result-type Rows struct {- cols []string- rows [][]driver.Value- pos int- nextErr map[int]error- closeErr error-}--// NewRows allows Rows to be created from a-// sql driver.Value slice or from the CSV string and-// to be used as sql driver.Rows-func NewRows(columns []string) *Rows {- return &Rows{cols: columns, nextErr: make(map[int]error)}-}--// CloseError allows to set an error-// which will be returned by rows.Close-// function.-//-// The close error will be triggered only in cases-// when rows.Next() EOF was not yet reached, that is-// a default sql library behavior-func (r *Rows) CloseError(err error) *Rows {- r.closeErr = err- return r-}--// RowError allows to set an error-// which will be returned when a given-// row number is read-func (r *Rows) RowError(row int, err error) *Rows {- r.nextErr[row] = err- return r-}--// AddRow composed from database driver.Value slice-// return the same instance to perform subsequent actions.-// Note that the number of values must match the number-// of columns-func (r *Rows) AddRow(values ...driver.Value) *Rows {- if len(values) != len(r.cols) {- panic("Expected number of values to match number of columns")- }-- row := make([]driver.Value, len(r.cols))- for i, v := range values {- row[i] = v- }-- r.rows = append(r.rows, row)- return r-}--// FromCSVString build rows from csv string.-// return the same instance to perform subsequent actions.-// Note that the number of values must match the number-// of columns-func (r *Rows) FromCSVString(s string) *Rows {- res := strings.NewReader(strings.TrimSpace(s))- csvReader := csv.NewReader(res)-- for {- res, err := csvReader.Read()- if err != nil || res == nil {- break- }-- row := make([]driver.Value, len(r.cols))- for i, v := range res {- row[i] = CSVColumnParser(strings.TrimSpace(v))- }- r.rows = append(r.rows, row)- }- return r-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_go18.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_go18.godeleted file mode 100644index 4ecf84e7e..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_go18.go+++ /dev/null@@ -1,20 +0,0 @@-// +build go1.8--package sqlmock--import "io"--// Implement the "RowsNextResultSet" interface-func (rs *rowSets) HasNextResultSet() bool {- return rs.pos+1 < len(rs.sets)-}--// Implement the "RowsNextResultSet" interface-func (rs *rowSets) NextResultSet() error {- if !rs.HasNextResultSet() {- return io.EOF- }-- rs.pos++- return nil-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_go18_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_go18_test.godeleted file mode 100644index 297e7c0bb..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_go18_test.go+++ /dev/null@@ -1,92 +0,0 @@-// +build go1.8--package sqlmock--import (- "fmt"- "testing"-)--func TestQueryMultiRows(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()-- rs1 := NewRows([]string{"id", "title"}).AddRow(5, "hello world")- rs2 := NewRows([]string{"name"}).AddRow("gopher").AddRow("john").AddRow("jane").RowError(2, fmt.Errorf("error"))-- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = \\?;SELECT name FROM users").- WithArgs(5).- WillReturnRows(rs1, rs2)-- rows, err := db.Query("SELECT id, title FROM articles WHERE id = ?;SELECT name FROM users", 5)- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }- defer rows.Close()-- if !rows.Next() {- t.Error("expected a row to be available in first result set")- }-- var id int- var name string-- err = rows.Scan(&id, &name)- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- if id != 5 || name != "hello world" {- t.Errorf("unexpected row values id: %v name: %v", id, name)- }-- if rows.Next() {- t.Error("was not expecting next row in first result set")- }-- if !rows.NextResultSet() {- t.Error("had to have next result set")- }-- if !rows.Next() {- t.Error("expected a row to be available in second result set")- }-- err = rows.Scan(&name)- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- if name != "gopher" {- t.Errorf("unexpected row name: %v", name)- }-- if !rows.Next() {- t.Error("expected a row to be available in second result set")- }-- err = rows.Scan(&name)- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- if name != "john" {- t.Errorf("unexpected row name: %v", name)- }-- if rows.Next() {- t.Error("expected next row to produce error")- }-- if rows.Err() == nil {- t.Error("expected an error, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_test.godeleted file mode 100644index 56e834ed0..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/rows_test.go+++ /dev/null@@ -1,265 +0,0 @@-package sqlmock--import (- "database/sql"- "fmt"- "testing"-)--func ExampleRows() {- db, mock, err := New()- if err != nil {- fmt.Println("failed to open sqlmock database:", err)- }- defer db.Close()-- rows := NewRows([]string{"id", "title"}).- AddRow(1, "one").- AddRow(2, "two")-- mock.ExpectQuery("SELECT").WillReturnRows(rows)-- rs, _ := db.Query("SELECT")- defer rs.Close()-- for rs.Next() {- var id int- var title string- rs.Scan(&id, &title)- fmt.Println("scanned id:", id, "and title:", title)- }-- if rs.Err() != nil {- fmt.Println("got rows error:", rs.Err())- }- // Output: scanned id: 1 and title: one- // scanned id: 2 and title: two-}--func ExampleRows_rowError() {- db, mock, err := New()- if err != nil {- fmt.Println("failed to open sqlmock database:", err)- }- defer db.Close()-- rows := NewRows([]string{"id", "title"}).- AddRow(0, "one").- AddRow(1, "two").- RowError(1, fmt.Errorf("row error"))- mock.ExpectQuery("SELECT").WillReturnRows(rows)-- rs, _ := db.Query("SELECT")- defer rs.Close()-- for rs.Next() {- var id int- var title string- rs.Scan(&id, &title)- fmt.Println("scanned id:", id, "and title:", title)- }-- if rs.Err() != nil {- fmt.Println("got rows error:", rs.Err())- }- // Output: scanned id: 0 and title: one- // got rows error: row error-}--func ExampleRows_closeError() {- db, mock, err := New()- if err != nil {- fmt.Println("failed to open sqlmock database:", err)- }- defer db.Close()-- rows := NewRows([]string{"id", "title"}).CloseError(fmt.Errorf("close error"))- mock.ExpectQuery("SELECT").WillReturnRows(rows)-- rs, _ := db.Query("SELECT")-- // Note: that close will return error only before rows EOF- // that is a default sql package behavior. If you run rs.Next()- // it will handle the error internally and return nil bellow- if err := rs.Close(); err != nil {- fmt.Println("got error:", err)- }-- // Output: got error: close error-}--func TestAllowsToSetRowsErrors(t *testing.T) {- t.Parallel()- db, mock, err := New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- rows := NewRows([]string{"id", "title"}).- AddRow(0, "one").- AddRow(1, "two").- RowError(1, fmt.Errorf("error"))- mock.ExpectQuery("SELECT").WillReturnRows(rows)-- rs, err := db.Query("SELECT")- if err != nil {- t.Fatalf("unexpected error: %s", err)- }- defer rs.Close()-- if !rs.Next() {- t.Fatal("expected the first row to be available")- }- if rs.Err() != nil {- t.Fatalf("unexpected error: %s", rs.Err())- }-- if rs.Next() {- t.Fatal("was not expecting the second row, since there should be an error")- }- if rs.Err() == nil {- t.Fatal("expected an error, but got none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Fatal(err)- }-}--func TestRowsCloseError(t *testing.T) {- t.Parallel()- db, mock, err := New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- rows := NewRows([]string{"id"}).CloseError(fmt.Errorf("close error"))- mock.ExpectQuery("SELECT").WillReturnRows(rows)-- rs, err := db.Query("SELECT")- if err != nil {- t.Fatalf("unexpected error: %s", err)- }-- if err := rs.Close(); err == nil {- t.Fatal("expected a close error")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Fatal(err)- }-}--func TestQuerySingleRow(t *testing.T) {- t.Parallel()- db, mock, err := New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- rows := NewRows([]string{"id"}).- AddRow(1).- AddRow(2)- mock.ExpectQuery("SELECT").WillReturnRows(rows)-- var id int- if err := db.QueryRow("SELECT").Scan(&id); err != nil {- t.Fatalf("unexpected error: %s", err)- }-- mock.ExpectQuery("SELECT").WillReturnRows(NewRows([]string{"id"}))- if err := db.QueryRow("SELECT").Scan(&id); err != sql.ErrNoRows {- t.Fatal("expected sql no rows error")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Fatal(err)- }-}--func TestRowsScanError(t *testing.T) {- t.Parallel()- db, mock, err := New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- r := NewRows([]string{"col1", "col2"}).AddRow("one", "two").AddRow("one", nil)- mock.ExpectQuery("SELECT").WillReturnRows(r)-- rs, err := db.Query("SELECT")- if err != nil {- t.Fatalf("unexpected error: %s", err)- }- defer rs.Close()-- var one, two string- if !rs.Next() || rs.Err() != nil || rs.Scan(&one, &two) != nil {- t.Fatal("unexpected error on first row scan")- }-- if !rs.Next() || rs.Err() != nil {- t.Fatal("unexpected error on second row read")- }-- err = rs.Scan(&one, &two)- if err == nil {- t.Fatal("expected an error for scan, but got none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Fatal(err)- }-}--func TestCSVRowParser(t *testing.T) {- t.Parallel()- rs := NewRows([]string{"col1", "col2"}).FromCSVString("a,NULL")- db, mock, err := New()- if err != nil {- t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)- }- defer db.Close()-- mock.ExpectQuery("SELECT").WillReturnRows(rs)-- rw, err := db.Query("SELECT")- if err != nil {- t.Fatalf("unexpected error: %s", err)- }- defer rw.Close()- var col1 string- var col2 []byte-- rw.Next()- if err = rw.Scan(&col1, &col2); err != nil {- t.Fatalf("unexpected error: %s", err)- }- if col1 != "a" {- t.Fatalf("expected col1 to be 'a', but got [%T]:%+v", col1, col1)- }- if col2 != nil {- t.Fatalf("expected col2 to be nil, but got [%T]:%+v", col2, col2)- }-}--func TestWrongNumberOfValues(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- defer db.Close()- defer func() {- recover()- }()- mock.ExpectQuery("SELECT ID FROM TABLE").WithArgs(101).WillReturnRows(NewRows([]string{"ID"}).AddRow(101, "Hello"))- db.Query("SELECT ID FROM TABLE", 101)- // shouldn't reach here- t.Error("expected panic from query")-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock.godeleted file mode 100644index b906a3fd4..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock.go+++ /dev/null@@ -1,525 +0,0 @@-/*-Package sqlmock is a mock library implementing sql driver. Which has one and only-purpose - to simulate any sql driver behavior in tests, without needing a real-database connection. It helps to maintain correct **TDD** workflow.--It does not require any modifications to your source code in order to test-and mock database operations. Supports concurrency and multiple database mocking.--The driver allows to mock any sql driver method behavior.-*/-package sqlmock--import (- "database/sql"- "database/sql/driver"- "fmt"- "regexp"- "time"-)--// Sqlmock interface serves to create expectations-// for any kind of database action in order to mock-// and test real database behavior.-type Sqlmock interface {-- // ExpectClose queues an expectation for this database- // action to be triggered. the *ExpectedClose allows- // to mock database response- ExpectClose() *ExpectedClose-- // ExpectationsWereMet checks whether all queued expectations- // were met in order. If any of them was not met - an error is returned.- ExpectationsWereMet() error-- // ExpectPrepare expects Prepare() to be called with sql query- // which match sqlRegexStr given regexp.- // the *ExpectedPrepare allows to mock database response.- // Note that you may expect Query() or Exec() on the *ExpectedPrepare- // statement to prevent repeating sqlRegexStr- ExpectPrepare(sqlRegexStr string) *ExpectedPrepare-- // ExpectQuery expects Query() or QueryRow() to be called with sql query- // which match sqlRegexStr given regexp.- // the *ExpectedQuery allows to mock database response.- ExpectQuery(sqlRegexStr string) *ExpectedQuery-- // ExpectExec expects Exec() to be called with sql query- // which match sqlRegexStr given regexp.- // the *ExpectedExec allows to mock database response- ExpectExec(sqlRegexStr string) *ExpectedExec-- // ExpectBegin expects *sql.DB.Begin to be called.- // the *ExpectedBegin allows to mock database response- ExpectBegin() *ExpectedBegin-- // ExpectCommit expects *sql.Tx.Commit to be called.- // the *ExpectedCommit allows to mock database response- ExpectCommit() *ExpectedCommit-- // ExpectRollback expects *sql.Tx.Rollback to be called.- // the *ExpectedRollback allows to mock database response- ExpectRollback() *ExpectedRollback-- // MatchExpectationsInOrder gives an option whether to match all- // expectations in the order they were set or not.- //- // By default it is set to - true. But if you use goroutines- // to parallelize your query executation, that option may- // be handy.- //- // This option may be turned on anytime during tests. As soon- // as it is switched to false, expectations will be matched- // in any order. Or otherwise if switched to true, any unmatched- // expectations will be expected in order- MatchExpectationsInOrder(bool)-}--type sqlmock struct {- ordered bool- dsn string- opened int- drv *mockDriver-- expected []expectation-}--func (c *sqlmock) open() (*sql.DB, Sqlmock, error) {- db, err := sql.Open("sqlmock", c.dsn)- if err != nil {- return db, c, err- }- return db, c, db.Ping()-}--func (c *sqlmock) ExpectClose() *ExpectedClose {- e := &ExpectedClose{}- c.expected = append(c.expected, e)- return e-}--func (c *sqlmock) MatchExpectationsInOrder(b bool) {- c.ordered = b-}--// Close a mock database driver connection. It may or may not-// be called depending on the sircumstances, but if it is called-// there must be an *ExpectedClose expectation satisfied.-// meets http://golang.org/pkg/database/sql/driver/#Conn interface-func (c *sqlmock) Close() error {- c.drv.Lock()- defer c.drv.Unlock()-- c.opened--- if c.opened == 0 {- delete(c.drv.conns, c.dsn)- }-- var expected *ExpectedClose- var fulfilled int- var ok bool- for _, next := range c.expected {- next.Lock()- if next.fulfilled() {- next.Unlock()- fulfilled++- continue- }-- if expected, ok = next.(*ExpectedClose); ok {- break- }-- next.Unlock()- if c.ordered {- return fmt.Errorf("call to database Close, was not expected, next expectation is: %s", next)- }- }-- if expected == nil {- msg := "call to database Close was not expected"- if fulfilled == len(c.expected) {- msg = "all expectations were already fulfilled, " + msg- }- return fmt.Errorf(msg)- }-- expected.triggered = true- expected.Unlock()- return expected.err-}--func (c *sqlmock) ExpectationsWereMet() error {- for _, e := range c.expected {- if !e.fulfilled() {- return fmt.Errorf("there is a remaining expectation which was not matched: %s", e)- }- }- return nil-}--// Begin meets http://golang.org/pkg/database/sql/driver/#Conn interface-func (c *sqlmock) Begin() (driver.Tx, error) {- ex, err := c.begin()- if err != nil {- return nil, err- }-- time.Sleep(ex.delay)- return c, nil-}--func (c *sqlmock) begin() (*ExpectedBegin, error) {- var expected *ExpectedBegin- var ok bool- var fulfilled int- for _, next := range c.expected {- next.Lock()- if next.fulfilled() {- next.Unlock()- fulfilled++- continue- }-- if expected, ok = next.(*ExpectedBegin); ok {- break- }-- next.Unlock()- if c.ordered {- return nil, fmt.Errorf("call to database transaction Begin, was not expected, next expectation is: %s", next)- }- }- if expected == nil {- msg := "call to database transaction Begin was not expected"- if fulfilled == len(c.expected) {- msg = "all expectations were already fulfilled, " + msg- }- return nil, fmt.Errorf(msg)- }-- expected.triggered = true- expected.Unlock()-- return expected, expected.err-}--func (c *sqlmock) ExpectBegin() *ExpectedBegin {- e := &ExpectedBegin{}- c.expected = append(c.expected, e)- return e-}--// Exec meets http://golang.org/pkg/database/sql/driver/#Execer-func (c *sqlmock) Exec(query string, args []driver.Value) (driver.Result, error) {- namedArgs := make([]namedValue, len(args))- for i, v := range args {- namedArgs[i] = namedValue{- Ordinal: i + 1,- Value: v,- }- }-- ex, err := c.exec(query, namedArgs)- if err != nil {- return nil, err- }-- time.Sleep(ex.delay)- return ex.result, nil-}--func (c *sqlmock) exec(query string, args []namedValue) (*ExpectedExec, error) {- query = stripQuery(query)- var expected *ExpectedExec- var fulfilled int- var ok bool- for _, next := range c.expected {- next.Lock()- if next.fulfilled() {- next.Unlock()- fulfilled++- continue- }-- if c.ordered {- if expected, ok = next.(*ExpectedExec); ok {- break- }- next.Unlock()- return nil, fmt.Errorf("call to exec query '%s' with args %+v, was not expected, next expectation is: %s", query, args, next)- }- if exec, ok := next.(*ExpectedExec); ok {- if err := exec.attemptMatch(query, args); err == nil {- expected = exec- break- }- }- next.Unlock()- }- if expected == nil {- msg := "call to exec '%s' query with args %+v was not expected"- if fulfilled == len(c.expected) {- msg = "all expectations were already fulfilled, " + msg- }- return nil, fmt.Errorf(msg, query, args)- }- defer expected.Unlock()-- if !expected.queryMatches(query) {- return nil, fmt.Errorf("exec query '%s', does not match regex '%s'", query, expected.sqlRegex.String())- }-- if err := expected.argsMatches(args); err != nil {- return nil, fmt.Errorf("exec query '%s', arguments do not match: %s", query, err)- }-- expected.triggered = true- if expected.err != nil {- return nil, expected.err // mocked to return error- }-- if expected.result == nil {- return nil, fmt.Errorf("exec query '%s' with args %+v, must return a database/sql/driver.result, but it was not set for expectation %T as %+v", query, args, expected, expected)- }-- return expected, nil-}--func (c *sqlmock) ExpectExec(sqlRegexStr string) *ExpectedExec {- e := &ExpectedExec{}- sqlRegexStr = stripQuery(sqlRegexStr)- e.sqlRegex = regexp.MustCompile(sqlRegexStr)- c.expected = append(c.expected, e)- return e-}--// Prepare meets http://golang.org/pkg/database/sql/driver/#Conn interface-func (c *sqlmock) Prepare(query string) (driver.Stmt, error) {- ex, err := c.prepare(query)- if err != nil {- return nil, err- }-- time.Sleep(ex.delay)- return &statement{c, query, ex.closeErr}, nil-}--func (c *sqlmock) prepare(query string) (*ExpectedPrepare, error) {- var expected *ExpectedPrepare- var fulfilled int- var ok bool- for _, next := range c.expected {- next.Lock()- if next.fulfilled() {- next.Unlock()- fulfilled++- continue- }-- if expected, ok = next.(*ExpectedPrepare); ok {- break- }-- next.Unlock()- if c.ordered {- return nil, fmt.Errorf("call to Prepare statement with query '%s', was not expected, next expectation is: %s", query, next)- }- }-- query = stripQuery(query)- if expected == nil {- msg := "call to Prepare '%s' query was not expected"- if fulfilled == len(c.expected) {- msg = "all expectations were already fulfilled, " + msg- }- return nil, fmt.Errorf(msg, query)- }- defer expected.Unlock()- if !expected.sqlRegex.MatchString(query) {- return nil, fmt.Errorf("query '%s', does not match regex [%s]", query, expected.sqlRegex.String())- }-- expected.triggered = true- return expected, expected.err-}--func (c *sqlmock) ExpectPrepare(sqlRegexStr string) *ExpectedPrepare {- sqlRegexStr = stripQuery(sqlRegexStr)- e := &ExpectedPrepare{sqlRegex: regexp.MustCompile(sqlRegexStr), mock: c}- c.expected = append(c.expected, e)- return e-}--type namedValue struct {- Name string- Ordinal int- Value driver.Value-}--// Query meets http://golang.org/pkg/database/sql/driver/#Queryer-func (c *sqlmock) Query(query string, args []driver.Value) (driver.Rows, error) {- namedArgs := make([]namedValue, len(args))- for i, v := range args {- namedArgs[i] = namedValue{- Ordinal: i + 1,- Value: v,- }- }-- ex, err := c.query(query, namedArgs)- if err != nil {- return nil, err- }-- time.Sleep(ex.delay)- return ex.rows, nil-}--func (c *sqlmock) query(query string, args []namedValue) (*ExpectedQuery, error) {- query = stripQuery(query)- var expected *ExpectedQuery- var fulfilled int- var ok bool- for _, next := range c.expected {- next.Lock()- if next.fulfilled() {- next.Unlock()- fulfilled++- continue- }-- if c.ordered {- if expected, ok = next.(*ExpectedQuery); ok {- break- }- next.Unlock()- return nil, fmt.Errorf("call to query '%s' with args %+v, was not expected, next expectation is: %s", query, args, next)- }- if qr, ok := next.(*ExpectedQuery); ok {- if err := qr.attemptMatch(query, args); err == nil {- expected = qr- break- }- }- next.Unlock()- }-- if expected == nil {- msg := "call to query '%s' with args %+v was not expected"- if fulfilled == len(c.expected) {- msg = "all expectations were already fulfilled, " + msg- }- return nil, fmt.Errorf(msg, query, args)- }-- defer expected.Unlock()-- if !expected.queryMatches(query) {- return nil, fmt.Errorf("query '%s', does not match regex [%s]", query, expected.sqlRegex.String())- }-- if err := expected.argsMatches(args); err != nil {- return nil, fmt.Errorf("exec query '%s', arguments do not match: %s", query, err)- }-- expected.triggered = true- if expected.err != nil {- return nil, expected.err // mocked to return error- }-- if expected.rows == nil {- return nil, fmt.Errorf("query '%s' with args %+v, must return a database/sql/driver.rows, but it was not set for expectation %T as %+v", query, args, expected, expected)- }- return expected, nil-}--func (c *sqlmock) ExpectQuery(sqlRegexStr string) *ExpectedQuery {- e := &ExpectedQuery{}- sqlRegexStr = stripQuery(sqlRegexStr)- e.sqlRegex = regexp.MustCompile(sqlRegexStr)- c.expected = append(c.expected, e)- return e-}--func (c *sqlmock) ExpectCommit() *ExpectedCommit {- e := &ExpectedCommit{}- c.expected = append(c.expected, e)- return e-}--func (c *sqlmock) ExpectRollback() *ExpectedRollback {- e := &ExpectedRollback{}- c.expected = append(c.expected, e)- return e-}--// Commit meets http://golang.org/pkg/database/sql/driver/#Tx-func (c *sqlmock) Commit() error {- var expected *ExpectedCommit- var fulfilled int- var ok bool- for _, next := range c.expected {- next.Lock()- if next.fulfilled() {- next.Unlock()- fulfilled++- continue- }-- if expected, ok = next.(*ExpectedCommit); ok {- break- }-- next.Unlock()- if c.ordered {- return fmt.Errorf("call to commit transaction, was not expected, next expectation is: %s", next)- }- }- if expected == nil {- msg := "call to commit transaction was not expected"- if fulfilled == len(c.expected) {- msg = "all expectations were already fulfilled, " + msg- }- return fmt.Errorf(msg)- }-- expected.triggered = true- expected.Unlock()- return expected.err-}--// Rollback meets http://golang.org/pkg/database/sql/driver/#Tx-func (c *sqlmock) Rollback() error {- var expected *ExpectedRollback- var fulfilled int- var ok bool- for _, next := range c.expected {- next.Lock()- if next.fulfilled() {- next.Unlock()- fulfilled++- continue- }-- if expected, ok = next.(*ExpectedRollback); ok {- break- }-- next.Unlock()- if c.ordered {- return fmt.Errorf("call to rollback transaction, was not expected, next expectation is: %s", next)- }- }- if expected == nil {- msg := "call to rollback transaction was not expected"- if fulfilled == len(c.expected) {- msg = "all expectations were already fulfilled, " + msg- }- return fmt.Errorf(msg)- }-- expected.triggered = true- expected.Unlock()- return expected.err-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_go18.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_go18.godeleted file mode 100644index c49429caa..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_go18.go+++ /dev/null@@ -1,101 +0,0 @@-// +build go1.8--package sqlmock--import (- "context"- "database/sql/driver"- "errors"- "time"-)--var ErrCancelled = errors.New("canceling query due to user request")--// Implement the "QueryerContext" interface-func (c *sqlmock) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {- namedArgs := make([]namedValue, len(args))- for i, nv := range args {- namedArgs[i] = namedValue(nv)- }-- ex, err := c.query(query, namedArgs)- if err != nil {- return nil, err- }-- select {- case <-time.After(ex.delay):- return ex.rows, nil- case <-ctx.Done():- return nil, ErrCancelled- }-}--// Implement the "ExecerContext" interface-func (c *sqlmock) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {- namedArgs := make([]namedValue, len(args))- for i, nv := range args {- namedArgs[i] = namedValue(nv)- }-- ex, err := c.exec(query, namedArgs)- if err != nil {- return nil, err- }-- select {- case <-time.After(ex.delay):- return ex.result, nil- case <-ctx.Done():- return nil, ErrCancelled- }-}--// Implement the "ConnBeginTx" interface-func (c *sqlmock) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {- ex, err := c.begin()- if err != nil {- return nil, err- }-- select {- case <-time.After(ex.delay):- return c, nil- case <-ctx.Done():- return nil, ErrCancelled- }-}--// Implement the "ConnPrepareContext" interface-func (c *sqlmock) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {- ex, err := c.prepare(query)- if err != nil {- return nil, err- }-- select {- case <-time.After(ex.delay):- return &statement{c, query, ex.closeErr}, nil- case <-ctx.Done():- return nil, ErrCancelled- }-}--// Implement the "Pinger" interface-// for now we do not have a Ping expectation-// may be something for the future-func (c *sqlmock) Ping(ctx context.Context) error {- return nil-}--// Implement the "StmtExecContext" interface-func (stmt *statement) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {- return stmt.conn.ExecContext(ctx, stmt.query, args)-}--// Implement the "StmtQueryContext" interface-func (stmt *statement) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {- return stmt.conn.QueryContext(ctx, stmt.query, args)-}--// @TODO maybe add ExpectedBegin.WithOptions(driver.TxOptions)diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_go18_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_go18_test.godeleted file mode 100644index 9eadcb591..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_go18_test.go+++ /dev/null@@ -1,426 +0,0 @@-// +build go1.8--package sqlmock--import (- "context"- "database/sql"- "testing"- "time"-)--func TestContextExecCancel(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("DELETE FROM users").- WillDelayFor(time.Second).- WillReturnResult(NewResult(1, 1))-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- _, err = db.ExecContext(ctx, "DELETE FROM users")- if err == nil {- t.Error("error was expected, but there was none")- }-- if err != ErrCancelled {- t.Errorf("was expecting cancel error, but got: %v", err)- }-- _, err = db.ExecContext(ctx, "DELETE FROM users")- if err != context.Canceled {- t.Error("error was expected since context was already done, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestPreparedStatementContextExecCancel(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.ExpectPrepare("DELETE FROM users").- ExpectExec().- WillDelayFor(time.Second).- WillReturnResult(NewResult(1, 1))-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- stmt, err := db.Prepare("DELETE FROM users")- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- _, err = stmt.ExecContext(ctx)- if err == nil {- t.Error("error was expected, but there was none")- }-- if err != ErrCancelled {- t.Errorf("was expecting cancel error, but got: %v", err)- }-- _, err = stmt.ExecContext(ctx)- if err != context.Canceled {- t.Error("error was expected since context was already done, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextExecWithNamedArg(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("DELETE FROM users").- WithArgs(sql.Named("id", 5)).- WillDelayFor(time.Second).- WillReturnResult(NewResult(1, 1))-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- _, err = db.ExecContext(ctx, "DELETE FROM users WHERE id = :id", sql.Named("id", 5))- if err == nil {- t.Error("error was expected, but there was none")- }-- if err != ErrCancelled {- t.Errorf("was expecting cancel error, but got: %v", err)- }-- _, err = db.ExecContext(ctx, "DELETE FROM users WHERE id = :id", sql.Named("id", 5))- if err != context.Canceled {- t.Error("error was expected since context was already done, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextExec(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("DELETE FROM users").- WillReturnResult(NewResult(1, 1))-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- res, err := db.ExecContext(ctx, "DELETE FROM users")- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- affected, err := res.RowsAffected()- if affected != 1 {- t.Errorf("expected affected rows 1, but got %v", affected)- }-- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextQueryCancel(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()-- rs := NewRows([]string{"id", "title"}).AddRow(5, "hello world")-- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = ?").- WithArgs(5).- WillDelayFor(time.Second).- WillReturnRows(rs)-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- _, err = db.QueryContext(ctx, "SELECT id, title FROM articles WHERE id = ?", 5)- if err == nil {- t.Error("error was expected, but there was none")- }-- if err != ErrCancelled {- t.Errorf("was expecting cancel error, but got: %v", err)- }-- _, err = db.QueryContext(ctx, "SELECT id, title FROM articles WHERE id = ?", 5)- if err != context.Canceled {- t.Error("error was expected since context was already done, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestPreparedStatementContextQueryCancel(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()-- rs := NewRows([]string{"id", "title"}).AddRow(5, "hello world")-- mock.ExpectPrepare("SELECT (.+) FROM articles WHERE id = ?").- ExpectQuery().- WithArgs(5).- WillDelayFor(time.Second).- WillReturnRows(rs)-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- stmt, err := db.Prepare("SELECT id, title FROM articles WHERE id = ?")- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- _, err = stmt.QueryContext(ctx, 5)- if err == nil {- t.Error("error was expected, but there was none")- }-- if err != ErrCancelled {- t.Errorf("was expecting cancel error, but got: %v", err)- }-- _, err = stmt.QueryContext(ctx, 5)- if err != context.Canceled {- t.Error("error was expected since context was already done, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextQuery(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()-- rs := NewRows([]string{"id", "title"}).AddRow(5, "hello world")-- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id =").- WithArgs(sql.Named("id", 5)).- WillDelayFor(time.Millisecond * 3).- WillReturnRows(rs)-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- rows, err := db.QueryContext(ctx, "SELECT id, title FROM articles WHERE id = :id", sql.Named("id", 5))- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- if !rows.Next() {- t.Error("expected one row, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextBeginCancel(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.ExpectBegin().WillDelayFor(time.Second)-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- _, err = db.BeginTx(ctx, nil)- if err == nil {- t.Error("error was expected, but there was none")- }-- if err != ErrCancelled {- t.Errorf("was expecting cancel error, but got: %v", err)- }-- _, err = db.BeginTx(ctx, nil)- if err != context.Canceled {- t.Error("error was expected since context was already done, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextBegin(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.ExpectBegin().WillDelayFor(time.Millisecond * 3)-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- tx, err := db.BeginTx(ctx, nil)- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- if tx == nil {- t.Error("expected tx, but there was nil")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextPrepareCancel(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.ExpectPrepare("SELECT").WillDelayFor(time.Second)-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- _, err = db.PrepareContext(ctx, "SELECT")- if err == nil {- t.Error("error was expected, but there was none")- }-- if err != ErrCancelled {- t.Errorf("was expecting cancel error, but got: %v", err)- }-- _, err = db.PrepareContext(ctx, "SELECT")- if err != context.Canceled {- t.Error("error was expected since context was already done, but there was none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestContextPrepare(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.ExpectPrepare("SELECT").WillDelayFor(time.Millisecond * 3)-- ctx, cancel := context.WithCancel(context.Background())-- go func() {- time.Sleep(time.Millisecond * 10)- cancel()- }()-- stmt, err := db.PrepareContext(ctx, "SELECT")- if err != nil {- t.Errorf("error was not expected, but got: %v", err)- }-- if stmt == nil {- t.Error("expected stmt, but there was nil")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_test.godeleted file mode 100644index fe4924b86..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/sqlmock_test.go+++ /dev/null@@ -1,998 +0,0 @@-package sqlmock--import (- "database/sql"- "fmt"- "strconv"- "sync"- "testing"- "time"-)--func cancelOrder(db *sql.DB, orderID int) error {- tx, _ := db.Begin()- _, _ = tx.Query("SELECT * FROM orders {0} FOR UPDATE", orderID)- err := tx.Rollback()- if err != nil {- return err- }- return nil-}--func Example() {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- // columns to be used for result- columns := []string{"id", "status"}- // expect transaction begin- mock.ExpectBegin()- // expect query to fetch order, match it with regexp- mock.ExpectQuery("SELECT (.+) FROM orders (.+) FOR UPDATE").- WithArgs(1).- WillReturnRows(NewRows(columns).AddRow(1, 1))- // expect transaction rollback, since order status is "cancelled"- mock.ExpectRollback()-- // run the cancel order function- someOrderID := 1- // call a function which executes expected database operations- err = cancelOrder(db, someOrderID)- if err != nil {- fmt.Printf("unexpected error: %s", err)- return- }-- // ensure all expectations have been met- if err = mock.ExpectationsWereMet(); err != nil {- fmt.Printf("unmet expectation error: %s", err)- }- // Output:-}--func TestIssue14EscapeSQL(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 mytable\\(a, b\\)").- WithArgs("A", "B").- WillReturnResult(NewResult(1, 1))-- _, err = db.Exec("INSERT INTO mytable(a, b) VALUES (?, ?)", "A", "B")- 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)- }-}--// test the case when db is not triggered and expectations-// are not asserted on close-func TestIssue4(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.ExpectQuery("some sql query which will not be called").- WillReturnRows(NewRows([]string{"id"}))-- if err := mock.ExpectationsWereMet(); err == nil {- t.Errorf("was expecting an error since query was not triggered")- }-}--func TestMockQuery(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()-- rs := NewRows([]string{"id", "title"}).FromCSVString("5,hello world")-- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = ?").- WithArgs(5).- WillReturnRows(rs)-- rows, err := db.Query("SELECT (.+) FROM articles WHERE id = ?", 5)- if err != nil {- t.Errorf("error '%s' was not expected while retrieving mock rows", err)- }-- defer func() {- if er := rows.Close(); er != nil {- t.Error("Unexpected error while trying to close rows")- }- }()-- if !rows.Next() {- t.Error("it must have had one row as result, but got empty result set instead")- }-- var id int- var title string-- err = rows.Scan(&id, &title)- if err != nil {- t.Errorf("error '%s' was not expected while trying to scan row", err)- }-- if id != 5 {- t.Errorf("expected mocked id to be 5, but got %d instead", id)- }-- if title != "hello world" {- t.Errorf("expected mocked title to be 'hello world', but got '%s' instead", title)- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestMockQueryTypes(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()-- columns := []string{"id", "timestamp", "sold"}-- timestamp := time.Now()- rs := NewRows(columns)- rs.AddRow(5, timestamp, true)-- mock.ExpectQuery("SELECT (.+) FROM sales WHERE id = ?").- WithArgs(5).- WillReturnRows(rs)-- rows, err := db.Query("SELECT (.+) FROM sales WHERE id = ?", 5)- if err != nil {- t.Errorf("error '%s' was not expected while retrieving mock rows", err)- }- defer func() {- if er := rows.Close(); er != nil {- t.Error("Unexpected error while trying to close rows")- }- }()- if !rows.Next() {- t.Error("it must have had one row as result, but got empty result set instead")- }-- var id int- var time time.Time- var sold bool-- err = rows.Scan(&id, &time, &sold)- if err != nil {- t.Errorf("error '%s' was not expected while trying to scan row", err)- }-- if id != 5 {- t.Errorf("expected mocked id to be 5, but got %d instead", id)- }-- if time != timestamp {- t.Errorf("expected mocked time to be %s, but got '%s' instead", timestamp, time)- }-- if sold != true {- t.Errorf("expected mocked boolean to be true, but got %v instead", sold)- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestTransactionExpectations(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()-- // begin and commit- mock.ExpectBegin()- mock.ExpectCommit()-- tx, err := db.Begin()- if err != nil {- t.Errorf("an error '%s' was not expected when beginning a transaction", err)- }-- err = tx.Commit()- if err != nil {- t.Errorf("an error '%s' was not expected when committing a transaction", err)- }-- // begin and rollback- mock.ExpectBegin()- mock.ExpectRollback()-- tx, err = db.Begin()- if err != nil {- t.Errorf("an error '%s' was not expected when beginning a transaction", err)- }-- err = tx.Rollback()- if err != nil {- t.Errorf("an error '%s' was not expected when rolling back a transaction", err)- }-- // begin with an error- mock.ExpectBegin().WillReturnError(fmt.Errorf("some err"))-- tx, err = db.Begin()- if err == nil {- t.Error("an error was expected when beginning a transaction, but got none")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestPrepareExpectations(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.ExpectPrepare("SELECT (.+) FROM articles WHERE id = ?")-- stmt, err := db.Prepare("SELECT (.+) FROM articles WHERE id = ?")- if err != nil {- t.Errorf("error '%s' was not expected while creating a prepared statement", err)- }- if stmt == nil {- t.Errorf("stmt was expected while creating a prepared statement")- }-- // expect something else, w/o ExpectPrepare()- var id int- var title string- rs := NewRows([]string{"id", "title"}).FromCSVString("5,hello world")-- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = ?").- WithArgs(5).- WillReturnRows(rs)-- err = stmt.QueryRow(5).Scan(&id, &title)- if err != nil {- t.Errorf("error '%s' was not expected while retrieving mock rows", err)- }-- mock.ExpectPrepare("SELECT (.+) FROM articles WHERE id = ?").- WillReturnError(fmt.Errorf("Some DB error occurred"))-- stmt, err = db.Prepare("SELECT id FROM articles WHERE id = ?")- if err == nil {- t.Error("error was expected while creating a prepared statement")- }- if stmt != nil {- t.Errorf("stmt was not expected while creating a prepared statement returning error")- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestPreparedQueryExecutions(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.ExpectPrepare("SELECT (.+) FROM articles WHERE id = ?")-- rs1 := NewRows([]string{"id", "title"}).FromCSVString("5,hello world")- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = ?").- WithArgs(5).- WillReturnRows(rs1)-- rs2 := NewRows([]string{"id", "title"}).FromCSVString("2,whoop")- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = ?").- WithArgs(2).- WillReturnRows(rs2)-- stmt, err := db.Prepare("SELECT id, title FROM articles WHERE id = ?")- if err != nil {- t.Errorf("error '%s' was not expected while creating a prepared statement", err)- }-- var id int- var title string- err = stmt.QueryRow(5).Scan(&id, &title)- if err != nil {- t.Errorf("error '%s' was not expected querying row from statement and scanning", err)- }-- if id != 5 {- t.Errorf("expected mocked id to be 5, but got %d instead", id)- }-- if title != "hello world" {- t.Errorf("expected mocked title to be 'hello world', but got '%s' instead", title)- }-- err = stmt.QueryRow(2).Scan(&id, &title)- if err != nil {- t.Errorf("error '%s' was not expected querying row from statement and scanning", err)- }-- if id != 2 {- t.Errorf("expected mocked id to be 2, but got %d instead", id)- }-- if title != "whoop" {- t.Errorf("expected mocked title to be 'whoop', but got '%s' instead", title)- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestUnexpectedOperations(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.ExpectPrepare("SELECT (.+) FROM articles WHERE id = ?")- stmt, err := db.Prepare("SELECT id, title FROM articles WHERE id = ?")- if err != nil {- t.Errorf("error '%s' was not expected while creating a prepared statement", err)- }-- var id int- var title string-- err = stmt.QueryRow(5).Scan(&id, &title)- if err == nil {- t.Error("error was expected querying row, since there was no such expectation")- }-- mock.ExpectRollback()-- if err := mock.ExpectationsWereMet(); err == nil {- t.Errorf("was expecting an error since query was not triggered")- }-}--func TestWrongExpectations(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.ExpectBegin()-- rs1 := NewRows([]string{"id", "title"}).FromCSVString("5,hello world")- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = ?").- WithArgs(5).- WillReturnRows(rs1)-- mock.ExpectCommit().WillReturnError(fmt.Errorf("deadlock occurred"))- mock.ExpectRollback() // won't be triggered-- var id int- var title string-- err = db.QueryRow("SELECT id, title FROM articles WHERE id = ? FOR UPDATE", 5).Scan(&id, &title)- if err == nil {- t.Error("error was expected while querying row, since there begin transaction expectation is not fulfilled")- }-- // lets go around and start transaction- tx, err := db.Begin()- if err != nil {- t.Errorf("an error '%s' was not expected when beginning a transaction", err)- }-- err = db.QueryRow("SELECT id, title FROM articles WHERE id = ? FOR UPDATE", 5).Scan(&id, &title)- if err != nil {- t.Errorf("error '%s' was not expected while querying row, since transaction was started", err)- }-- err = tx.Commit()- if err == nil {- t.Error("a deadlock error was expected when committing a transaction", err)- }-- if err := mock.ExpectationsWereMet(); err == nil {- t.Errorf("was expecting an error since query was not triggered")- }-}--func TestExecExpectations(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()-- result := NewResult(1, 1)- mock.ExpectExec("^INSERT INTO articles").- WithArgs("hello").- WillReturnResult(result)-- res, err := db.Exec("INSERT INTO articles (title) VALUES (?)", "hello")- if err != nil {- t.Errorf("error '%s' was not expected, while inserting a row", err)- }-- id, err := res.LastInsertId()- if err != nil {- t.Errorf("error '%s' was not expected, while getting a last insert id", err)- }-- affected, err := res.RowsAffected()- if err != nil {- t.Errorf("error '%s' was not expected, while getting affected rows", err)- }-- if id != 1 {- t.Errorf("expected last insert id to be 1, but got %d instead", id)- }-- if affected != 1 {- t.Errorf("expected affected rows to be 1, but got %d instead", affected)- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestRowBuilderAndNilTypes(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()-- rs := NewRows([]string{"id", "active", "created", "status"}).- AddRow(1, true, time.Now(), 5).- AddRow(2, false, nil, nil)-- mock.ExpectQuery("SELECT (.+) FROM sales").WillReturnRows(rs)-- rows, err := db.Query("SELECT * FROM sales")- if err != nil {- t.Errorf("error '%s' was not expected while retrieving mock rows", err)- }- defer func() {- if er := rows.Close(); er != nil {- t.Error("Unexpected error while trying to close rows")- }- }()-- // NullTime and NullInt are used from stubs_test.go- var (- id int- active bool- created NullTime- status NullInt- )-- if !rows.Next() {- t.Error("it must have had row in rows, but got empty result set instead")- }-- err = rows.Scan(&id, &active, &created, &status)- if err != nil {- t.Errorf("error '%s' was not expected while trying to scan row", err)- }-- if id != 1 {- t.Errorf("expected mocked id to be 1, but got %d instead", id)- }-- if !active {- t.Errorf("expected 'active' to be 'true', but got '%v' instead", active)- }-- if !created.Valid {- t.Errorf("expected 'created' to be valid, but it %+v is not", created)- }-- if !status.Valid {- t.Errorf("expected 'status' to be valid, but it %+v is not", status)- }-- if status.Integer != 5 {- t.Errorf("expected 'status' to be '5', but got '%d'", status.Integer)- }-- // test second row- if !rows.Next() {- t.Error("it must have had row in rows, but got empty result set instead")- }-- err = rows.Scan(&id, &active, &created, &status)- if err != nil {- t.Errorf("error '%s' was not expected while trying to scan row", err)- }-- if id != 2 {- t.Errorf("expected mocked id to be 2, but got %d instead", id)- }-- if active {- t.Errorf("expected 'active' to be 'false', but got '%v' instead", active)- }-- if created.Valid {- t.Errorf("expected 'created' to be invalid, but it %+v is not", created)- }-- if status.Valid {- t.Errorf("expected 'status' to be invalid, but it %+v is not", status)- }-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestArgumentReflectValueTypeError(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()-- rs := NewRows([]string{"id"}).AddRow(1)-- mock.ExpectQuery("SELECT (.+) FROM sales").WithArgs(5.5).WillReturnRows(rs)-- _, err = db.Query("SELECT * FROM sales WHERE x = ?", 5)- if err == nil {- t.Error("Expected error, but got none")- }-}--func TestGoroutineExecutionWithUnorderedExpectationMatching(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()-- // note this line is important for unordered expectation matching- mock.MatchExpectationsInOrder(false)-- result := NewResult(1, 1)-- mock.ExpectExec("^UPDATE one").WithArgs("one").WillReturnResult(result)- mock.ExpectExec("^UPDATE two").WithArgs("one", "two").WillReturnResult(result)- mock.ExpectExec("^UPDATE three").WithArgs("one", "two", "three").WillReturnResult(result)-- var wg sync.WaitGroup- queries := map[string][]interface{}{- "one": []interface{}{"one"},- "two": []interface{}{"one", "two"},- "three": []interface{}{"one", "two", "three"},- }-- wg.Add(len(queries))- for table, args := range queries {- go func(tbl string, a []interface{}) {- if _, err := db.Exec("UPDATE "+tbl, a...); err != nil {- t.Errorf("error was not expected: %s", err)- }- wg.Done()- }(table, args)- }-- wg.Wait()-- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func ExampleSqlmock_goroutines() {- db, mock, err := New()- if err != nil {- fmt.Println("failed to open sqlmock database:", err)- }- defer db.Close()-- // note this line is important for unordered expectation matching- mock.MatchExpectationsInOrder(false)-- result := NewResult(1, 1)-- mock.ExpectExec("^UPDATE one").WithArgs("one").WillReturnResult(result)- mock.ExpectExec("^UPDATE two").WithArgs("one", "two").WillReturnResult(result)- mock.ExpectExec("^UPDATE three").WithArgs("one", "two", "three").WillReturnResult(result)-- var wg sync.WaitGroup- queries := map[string][]interface{}{- "one": []interface{}{"one"},- "two": []interface{}{"one", "two"},- "three": []interface{}{"one", "two", "three"},- }-- wg.Add(len(queries))- for table, args := range queries {- go func(tbl string, a []interface{}) {- if _, err := db.Exec("UPDATE "+tbl, a...); err != nil {- fmt.Println("error was not expected:", err)- }- wg.Done()- }(table, args)- }-- wg.Wait()-- if err := mock.ExpectationsWereMet(); err != nil {- fmt.Println("there were unfulfilled expections:", err)- }- // Output:-}--// False Positive - passes despite mismatched Exec-// see #37 issue-func TestRunExecsWithOrderedShouldNotMeetAllExpectations(t *testing.T) {- db, dbmock, _ := New()- dbmock.ExpectExec("THE FIRST EXEC")- dbmock.ExpectExec("THE SECOND EXEC")-- _, _ = db.Exec("THE FIRST EXEC")- _, _ = db.Exec("THE WRONG EXEC")-- err := dbmock.ExpectationsWereMet()- if err == nil {- t.Fatal("was expecting an error, but there wasn't any")- }-}--// False Positive - passes despite mismatched Exec-// see #37 issue-func TestRunQueriesWithOrderedShouldNotMeetAllExpectations(t *testing.T) {- db, dbmock, _ := New()- dbmock.ExpectQuery("THE FIRST QUERY")- dbmock.ExpectQuery("THE SECOND QUERY")-- _, _ = db.Query("THE FIRST QUERY")- _, _ = db.Query("THE WRONG QUERY")-- err := dbmock.ExpectationsWereMet()- if err == nil {- t.Fatal("was expecting an error, but there wasn't any")- }-}--func TestRunExecsWithExpectedErrorMeetsExpectations(t *testing.T) {- db, dbmock, _ := New()- dbmock.ExpectExec("THE FIRST EXEC").WillReturnError(fmt.Errorf("big bad bug"))- dbmock.ExpectExec("THE SECOND EXEC").WillReturnResult(NewResult(0, 0))-- _, _ = db.Exec("THE FIRST EXEC")- _, _ = db.Exec("THE SECOND EXEC")-- err := dbmock.ExpectationsWereMet()- if err != nil {- t.Fatalf("all expectations should be met: %s", err)- }-}--func TestRunQueryWithExpectedErrorMeetsExpectations(t *testing.T) {- db, dbmock, _ := New()- dbmock.ExpectQuery("THE FIRST QUERY").WillReturnError(fmt.Errorf("big bad bug"))- dbmock.ExpectQuery("THE SECOND QUERY").WillReturnRows(NewRows([]string{"col"}).AddRow(1))-- _, _ = db.Query("THE FIRST QUERY")- _, _ = db.Query("THE SECOND QUERY")-- err := dbmock.ExpectationsWereMet()- if err != nil {- t.Fatalf("all expectations should be met: %s", err)- }-}--func TestEmptyRowSet(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()-- rs := NewRows([]string{"id", "title"})-- mock.ExpectQuery("SELECT (.+) FROM articles WHERE id = ?").- WithArgs(5).- WillReturnRows(rs)-- rows, err := db.Query("SELECT (.+) FROM articles WHERE id = ?", 5)- if err != nil {- t.Errorf("error '%s' was not expected while retrieving mock rows", err)- }-- defer func() {- if er := rows.Close(); er != nil {- t.Error("Unexpected error while trying to close rows")- }- }()-- if rows.Next() {- t.Error("expected no rows but got one")- }-- err = mock.ExpectationsWereMet()- if err != nil {- t.Fatalf("all expectations should be met: %s", err)- }-}--// Based on issue #50-func TestPrepareExpectationNotFulfilled(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.ExpectPrepare("^BADSELECT$")-- if _, err := db.Prepare("SELECT"); err == nil {- t.Fatal("prepare should not match expected query string")- }-- if err := mock.ExpectationsWereMet(); err == nil {- t.Errorf("was expecting an error, since prepared statement query does not match, but there was none")- }-}--func TestRollbackThrow(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- // columns to be used for result- columns := []string{"id", "status"}- // expect transaction begin- mock.ExpectBegin()- // expect query to fetch order, match it with regexp- mock.ExpectQuery("SELECT (.+) FROM orders (.+) FOR UPDATE").- WithArgs(1).- WillReturnRows(NewRows(columns).AddRow(1, 1))- // expect transaction rollback, since order status is "cancelled"- mock.ExpectRollback().WillReturnError(fmt.Errorf("rollback failed"))-- // run the cancel order function- someOrderID := 1- // call a function which executes expected database operations- err = cancelOrder(db, someOrderID)- if err == nil {- t.Error("an error was expected when rolling back transaction, but got none")- }-- // ensure all expectations have been met- if err = mock.ExpectationsWereMet(); err != nil {- t.Errorf("unmet expectation error: %s", err)- }- // Output:-}--func TestUnexpectedCommit(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- mock.ExpectBegin()- tx, _ := db.Begin()- if err := tx.Commit(); err == nil {- t.Error("an error was expected when calling commit, but got none")- }-}--func TestUnexpectedCommitOrder(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- mock.ExpectBegin()- mock.ExpectRollback().WillReturnError(fmt.Errorf("Rollback failed"))- tx, _ := db.Begin()- if err := tx.Commit(); err == nil {- t.Error("an error was expected when calling commit, but got none")- }-}--func TestExpectedCommitOrder(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- mock.ExpectCommit().WillReturnError(fmt.Errorf("Commit failed"))- if _, err := db.Begin(); err == nil {- t.Error("an error was expected when calling begin, but got none")- }-}--func TestUnexpectedRollback(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- mock.ExpectBegin()- tx, _ := db.Begin()- if err := tx.Rollback(); err == nil {- t.Error("an error was expected when calling rollback, but got none")- }-}--func TestUnexpectedRollbackOrder(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- mock.ExpectBegin()-- tx, _ := db.Begin()- if err := tx.Rollback(); err == nil {- t.Error("an error was expected when calling rollback, but got none")- }-}--func TestPrepareExec(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- defer db.Close()- mock.ExpectBegin()- ep := mock.ExpectPrepare("INSERT INTO ORDERS\\(ID, STATUS\\) VALUES \\(\\?, \\?\\)")- for i := 0; i < 3; i++ {- ep.ExpectExec().WillReturnResult(NewResult(1, 1))- }- mock.ExpectCommit()- tx, _ := db.Begin()- stmt, err := tx.Prepare("INSERT INTO ORDERS(ID, STATUS) VALUES (?, ?)")- if err != nil {- t.Fatal(err)- }- defer stmt.Close()- for i := 0; i < 3; i++ {- _, err := stmt.Exec(i, "Hello"+strconv.Itoa(i))- if err != nil {- t.Fatal(err)- }- }- tx.Commit()- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestPrepareQuery(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- defer db.Close()- mock.ExpectBegin()- ep := mock.ExpectPrepare("SELECT ID, STATUS FROM ORDERS WHERE ID = \\?")- ep.ExpectQuery().WithArgs(101).WillReturnRows(NewRows([]string{"ID", "STATUS"}).AddRow(101, "Hello"))- mock.ExpectCommit()- tx, _ := db.Begin()- stmt, err := tx.Prepare("SELECT ID, STATUS FROM ORDERS WHERE ID = ?")- if err != nil {- t.Fatal(err)- }- defer stmt.Close()- rows, err := stmt.Query(101)- if err != nil {- t.Fatal(err)- }- defer rows.Close()- for rows.Next() {- var (- id int- status string- )- if rows.Scan(&id, &status); id != 101 || status != "Hello" {- t.Fatal("wrong query results")- }-- }- tx.Commit()- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestExpectedCloseError(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- mock.ExpectClose().WillReturnError(fmt.Errorf("Close failed"))- if err := db.Close(); err == nil {- t.Error("an error was expected when calling close, but got none")- }- if err := mock.ExpectationsWereMet(); err != nil {- t.Errorf("there were unfulfilled expections: %s", err)- }-}--func TestExpectedCloseOrder(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- defer db.Close()- mock.ExpectClose().WillReturnError(fmt.Errorf("Close failed"))- db.Begin()- if err := mock.ExpectationsWereMet(); err == nil {- t.Error("expected error on ExpectationsWereMet")- }-}--func TestExpectedBeginOrder(t *testing.T) {- // Open new mock database- db, mock, err := New()- if err != nil {- fmt.Println("error creating mock database")- return- }- mock.ExpectBegin().WillReturnError(fmt.Errorf("Begin failed"))- if err := db.Close(); err == nil {- t.Error("an error was expected when calling close, but got none")- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/statement.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/statement.godeleted file mode 100644index df73740e1..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/statement.go+++ /dev/null@@ -1,27 +0,0 @@-package sqlmock--import (- "database/sql/driver"-)--type statement struct {- conn *sqlmock- query string- err error-}--func (stmt *statement) Close() error {- return stmt.err-}--func (stmt *statement) NumInput() int {- return -1-}--func (stmt *statement) Exec(args []driver.Value) (driver.Result, error) {- return stmt.conn.Exec(stmt.query, args)-}--func (stmt *statement) Query(args []driver.Value) (driver.Rows, error) {- return stmt.conn.Query(stmt.query, args)-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/statement_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/statement_test.godeleted file mode 100644index f951f6310..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/statement_test.go+++ /dev/null@@ -1,33 +0,0 @@-// +build go1.6--package sqlmock--import (- "errors"- "testing"-)--func TestExpectedPreparedStatemtCloseError(t *testing.T) {- conn, mock, err := New()- if err != nil {- t.Fatal("failed to open sqlmock database:", err)- }-- mock.ExpectBegin()- want := errors.New("STMT ERROR")- mock.ExpectPrepare("SELECT").WillReturnCloseError(want)-- txn, err := conn.Begin()- if err != nil {- t.Fatal("unexpected error while opening transaction:", err)- }-- stmt, err := txn.Prepare("SELECT")- if err != nil {- t.Fatal("unexpected error while preparing a statement:", err)- }-- if err := stmt.Close(); err != want {- t.Fatalf("Got = %v, want = %v", err, want)- }-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/stubs_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/stubs_test.godeleted file mode 100644index d3c6003f6..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/stubs_test.go+++ /dev/null@@ -1,76 +0,0 @@-package sqlmock--import (- "database/sql/driver"- "fmt"- "strconv"- "time"-)--type NullTime struct {- Time time.Time- Valid bool // Valid is true if Time is not NULL-}--type NullInt struct {- Integer int- Valid bool-}--// Satisfy sql.Scanner interface-func (ni *NullInt) Scan(value interface{}) (err error) {- if value == nil {- ni.Integer, ni.Valid = 0, false- return- }-- switch v := value.(type) {- case int, int8, int16, int32, int64:- ni.Integer, ni.Valid = v.(int), true- return- case []byte:- ni.Integer, err = strconv.Atoi(string(v))- ni.Valid = (err == nil)- return- case string:- ni.Integer, err = strconv.Atoi(v)- ni.Valid = (err == nil)- return- }-- ni.Valid = false- return fmt.Errorf("Can't convert %T to integer", value)-}--// Satisfy sql.Valuer interface.-func (ni NullInt) Value() (driver.Value, error) {- if !ni.Valid {- return nil, nil- }- return ni.Integer, nil-}--// Satisfy sql.Scanner interface-func (nt *NullTime) Scan(value interface{}) (err error) {- if value == nil {- nt.Time, nt.Valid = time.Time{}, false- return- }-- switch v := value.(type) {- case time.Time:- nt.Time, nt.Valid = v, true- return- }-- nt.Valid = false- return fmt.Errorf("Can't convert %T to time.Time", value)-}--// Satisfy sql.Valuer interface.-func (nt NullTime) Value() (driver.Value, error) {- if !nt.Valid {- return nil, nil- }- return nt.Time, nil-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/util.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/util.godeleted file mode 100644index 072e380f5..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/util.go+++ /dev/null@@ -1,13 +0,0 @@-package sqlmock--import (- "regexp"- "strings"-)--var re = regexp.MustCompile("\\s+")--// strip out new lines and trim spaces-func stripQuery(q string) (s string) {- return strings.TrimSpace(re.ReplaceAllString(q, " "))-}diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/util_test.go b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/util_test.godeleted file mode 100644index c4b3974e4..000000000--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/util_test.go+++ /dev/null@@ -1,21 +0,0 @@-package sqlmock--import (- "testing"-)--func TestQueryStringStripping(t *testing.T) {- assert := func(actual, expected string) {- if res := stripQuery(actual); res != expected {- t.Errorf("Expected '%s' to be '%s', but got '%s'", actual, expected, res)- }- }-- assert(" SELECT 1", "SELECT 1")- assert("SELECT 1 FROM d", "SELECT 1 FROM d")- assert(`- SELECT c- FROM D-`, "SELECT c FROM D")- assert("UPDATE (.+) SET ", "UPDATE (.+) SET")-}