Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

use real postgres database

goenning24ea6418d6b4
diff --git a/.test.env b/.test.env
index 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=disable
AUTH_ENDPOINT=http://login.test.canhearyou.com:3000
JWT_SECRET=I1$$MplJ-007A8]G#RE0VVfvv:I~o6+2yA0@)>2|{K$Z1628z9;w7lAsZ
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index 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
- yarn
script:
diff --git a/app/postgres/feedback_test.go b/app/postgres/feedback_test.go
index d627c2068..bdb2eb1b8 100644
--- a/app/postgres/feedback_test.go
+++ b/app/postgres/feedback_test.go
@@ -1,70 +1,37 @@
package postgres_test
import (
- "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.go
deleted file mode 100644
index 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.go
index 0535fd83b..ad9a2ec2f 100644
--- a/app/postgres/identity_test.go
+++ b/app/postgres/identity_test.go
@@ -1,12 +1,8 @@
package postgres_test
import (
- "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.go
index 3bc5e4c19..fa0d8f12c 100644
--- a/app/postgres/infra_test.go
+++ b/app/postgres/infra_test.go
@@ -1,37 +1,18 @@
package postgres_test
import (
- "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.go
new file mode 100644
index 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.yml
index 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 file
diff --git a/glide.lock b/glide.lock
index 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:00
imports:
- name: cloud.google.com/go
version: 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.v2
version: a3f3340b5840cee44f372bddb5880fcbc419b46a
diff --git a/glide.yaml b/glide.yaml
index d8ccb4c82..7b6fcecfa 100644
--- a/glide.yaml
+++ b/glide.yaml
@@ -17,4 +17,3 @@ import:
- google
testImport:
- package: github.com/onsi/gomega
-- package: gopkg.in/DATA-DOG/go-sqlmock.v1
diff --git a/main.go b/main.go
index 269dd24b3..bd292f55b 100644
--- a/main.go
+++ b/main.go
@@ -18,10 +18,6 @@ var buildtime string
var 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/.gitignore
deleted file mode 100644
index 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/basic
diff --git a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.travis.yml b/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/.travis.yml
deleted file mode 100644
index 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/LICENSE
deleted file mode 100644
index 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.md
deleted file mode 100644
index f3d54873a..000000000
--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/README.md
+++ /dev/null
@@ -1,223 +0,0 @@
-[![Build Status](https://travis-ci.org/DATA-DOG/go-sqlmock.png)](https://travis-ci.org/DATA-DOG/go-sqlmock)
-[![GoDoc](https://godoc.org/github.com/DATA-DOG/go-sqlmock?status.png)](https://godoc.org/github.com/DATA-DOG/go-sqlmock)
-[![codecov.io](https://codecov.io/github/DATA-DOG/go-sqlmock/branch/master/graph/badge.svg)](https://codecov.io/github/DATA-DOG/go-sqlmock)
-
-# Sql driver mock for Golang
-
-**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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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 file
diff --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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index c7842af75..000000000
--- a/vendor/gopkg.in/DATA-DOG/go-sqlmock.v1/examples/doc.go
+++ /dev/null
@@ -1 +0,0 @@
-package examples
diff --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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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")
-}