From 1e2e17d0353189a5bc2cf49bf8b6f98b2f70b920 Mon Sep 17 00:00:00 2001 From: Ermachkov Yaroslav Date: Thu, 30 Oct 2025 16:16:10 +0300 Subject: [PATCH] pool: removed deprecated methods Removed deprecated pool's methods. Related tests are updated (deleted or refactored). Also removed mentioned methods in interfaces declarations. Fixes #478 --- CHANGELOG.md | 1 + MIGRATION.md | 1 + connector.go | 110 ---- pool/connection_pool.go | 518 ------------------- pool/connection_pool_test.go | 500 ++++++++++-------- pool/connector.go | 320 ------------ pool/connector_test.go | 956 ----------------------------------- pool/pooler.go | 138 ----- 8 files changed, 298 insertions(+), 2246 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index eb283b863..810bd2904 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,6 +19,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release. * `box.New` returns an error instead of panic (#448). * Now cases of `<-ctx.Done()` returns wrapped error provided by `ctx.Cause()`. Allows you compare it using `errors.Is/As` (#457). +* Removed deprecated `pool` methods, related interfaces and tests are updated (#478). ### Fixed diff --git a/MIGRATION.md b/MIGRATION.md index ea82c8815..3044dbffc 100644 --- a/MIGRATION.md +++ b/MIGRATION.md @@ -11,6 +11,7 @@ TODO * Required Go version is `1.24` now. * `box.New` returns an error instead of panic * Added `box.MustNew` wrapper for `box.New` without an error +* Removed deprecated `pool` methods, related interfaces and tests are updated. ## Migration from v1.x.x to v2.x.x diff --git a/connector.go b/connector.go index 9917cff0f..7112eb099 100644 --- a/connector.go +++ b/connector.go @@ -16,114 +16,4 @@ type Connector interface { NewPrepared(expr string) (*Prepared, error) NewStream() (*Stream, error) NewWatcher(key string, callback WatchCallback) (Watcher, error) - - // Deprecated: the method will be removed in the next major version, - // use a PingRequest object + Do() instead. - Ping() ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - Select(space, index interface{}, offset, limit uint32, iterator Iter, - key interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use an InsertRequest object + Do() instead. - Insert(space interface{}, tuple interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a ReplicaRequest object + Do() instead. - Replace(space interface{}, tuple interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a DeleteRequest object + Do() instead. - Delete(space, index interface{}, key interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a UpdateRequest object + Do() instead. - Update(space, index interface{}, key interface{}, ops *Operations) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a UpsertRequest object + Do() instead. - Upsert(space interface{}, tuple interface{}, ops *Operations) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a CallRequest object + Do() instead. - Call(functionName string, args interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a Call16Request object + Do() instead. - Call16(functionName string, args interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a Call17Request object + Do() instead. - Call17(functionName string, args interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use an EvalRequest object + Do() instead. - Eval(expr string, args interface{}) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use an ExecuteRequest object + Do() instead. - Execute(expr string, args interface{}) ([]interface{}, error) - - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - GetTyped(space, index interface{}, key interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - SelectTyped(space, index interface{}, offset, limit uint32, iterator Iter, key interface{}, - result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use an InsertRequest object + Do() instead. - InsertTyped(space interface{}, tuple interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use a ReplaceRequest object + Do() instead. - ReplaceTyped(space interface{}, tuple interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use a DeleteRequest object + Do() instead. - DeleteTyped(space, index interface{}, key interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use a UpdateRequest object + Do() instead. - UpdateTyped(space, index interface{}, key interface{}, ops *Operations, - result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use a CallRequest object + Do() instead. - CallTyped(functionName string, args interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use a Call16Request object + Do() instead. - Call16Typed(functionName string, args interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use a Call17Request object + Do() instead. - Call17Typed(functionName string, args interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use an EvalRequest object + Do() instead. - EvalTyped(expr string, args interface{}, result interface{}) error - // Deprecated: the method will be removed in the next major version, - // use an ExecuteRequest object + Do() instead. - ExecuteTyped(expr string, args interface{}, - result interface{}) (SQLInfo, []ColumnMetaData, error) - - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - SelectAsync(space, index interface{}, offset, limit uint32, iterator Iter, - key interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use an InsertRequest object + Do() instead. - InsertAsync(space interface{}, tuple interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use a ReplaceRequest object + Do() instead. - ReplaceAsync(space interface{}, tuple interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use a DeleteRequest object + Do() instead. - DeleteAsync(space, index interface{}, key interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use a UpdateRequest object + Do() instead. - UpdateAsync(space, index interface{}, key interface{}, ops *Operations) *Future - // Deprecated: the method will be removed in the next major version, - // use a UpsertRequest object + Do() instead. - UpsertAsync(space interface{}, tuple interface{}, ops *Operations) *Future - // Deprecated: the method will be removed in the next major version, - // use a CallRequest object + Do() instead. - CallAsync(functionName string, args interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use a Call16Request object + Do() instead. - Call16Async(functionName string, args interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use a Call17Request object + Do() instead. - Call17Async(functionName string, args interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use an EvalRequest object + Do() instead. - EvalAsync(expr string, args interface{}) *Future - // Deprecated: the method will be removed in the next major version, - // use an ExecuteRequest object + Do() instead. - ExecuteAsync(expr string, args interface{}) *Future } diff --git a/pool/connection_pool.go b/pool/connection_pool.go index 572fe6cde..9d020ba8e 100644 --- a/pool/connection_pool.go +++ b/pool/connection_pool.go @@ -443,510 +443,6 @@ func (p *ConnectionPool) GetInfo() map[string]ConnectionInfo { return info } -// Ping sends empty request to Tarantool to check connection. -// -// Deprecated: the method will be removed in the next major version, -// use a PingRequest object + Do() instead. -func (p *ConnectionPool) Ping(userMode Mode) ([]interface{}, error) { - conn, err := p.getNextConnection(userMode) - if err != nil { - return nil, err - } - - return conn.Ping() -} - -// Select performs select to box space. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (p *ConnectionPool) Select(space, index interface{}, - offset, limit uint32, - iterator tarantool.Iter, key interface{}, userMode ...Mode) ([]interface{}, error) { - conn, err := p.getConnByMode(ANY, userMode) - if err != nil { - return nil, err - } - - return conn.Select(space, index, offset, limit, iterator, key) -} - -// Insert performs insertion to box space. -// Tarantool will reject Insert when tuple with same primary key exists. -// -// Deprecated: the method will be removed in the next major version, -// use an InsertRequest object + Do() instead. -func (p *ConnectionPool) Insert(space interface{}, tuple interface{}, - userMode ...Mode) ([]interface{}, error) { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return nil, err - } - - return conn.Insert(space, tuple) -} - -// Replace performs "insert or replace" action to box space. -// If tuple with same primary key exists, it will be replaced. -// -// Deprecated: the method will be removed in the next major version, -// use a ReplaceRequest object + Do() instead. -func (p *ConnectionPool) Replace(space interface{}, tuple interface{}, - userMode ...Mode) ([]interface{}, error) { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return nil, err - } - - return conn.Replace(space, tuple) -} - -// Delete performs deletion of a tuple by key. -// Result will contain array with deleted tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a DeleteRequest object + Do() instead. -func (p *ConnectionPool) Delete(space, index interface{}, key interface{}, - userMode ...Mode) ([]interface{}, error) { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return nil, err - } - - return conn.Delete(space, index, key) -} - -// Update performs update of a tuple by key. -// Result will contain array with updated tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a UpdateRequest object + Do() instead. -func (p *ConnectionPool) Update(space, index interface{}, key interface{}, - ops *tarantool.Operations, userMode ...Mode) ([]interface{}, error) { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return nil, err - } - - return conn.Update(space, index, key, ops) -} - -// Upsert performs "update or insert" action of a tuple by key. -// Result will not contain any tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a UpsertRequest object + Do() instead. -func (p *ConnectionPool) Upsert(space interface{}, tuple interface{}, - ops *tarantool.Operations, userMode ...Mode) ([]interface{}, error) { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return nil, err - } - - return conn.Upsert(space, tuple, ops) -} - -// Call calls registered Tarantool function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a CallRequest object + Do() instead. -func (p *ConnectionPool) Call(functionName string, args interface{}, - userMode Mode) ([]interface{}, error) { - conn, err := p.getNextConnection(userMode) - if err != nil { - return nil, err - } - - return conn.Call(functionName, args) -} - -// Call16 calls registered Tarantool function. -// It uses request code for Tarantool 1.6, result is an array of arrays. -// Deprecated since Tarantool 1.7.2. -// -// Deprecated: the method will be removed in the next major version, -// use a Call16Request object + Do() instead. -func (p *ConnectionPool) Call16(functionName string, args interface{}, - userMode Mode) ([]interface{}, error) { - conn, err := p.getNextConnection(userMode) - if err != nil { - return nil, err - } - - return conn.Call16(functionName, args) -} - -// Call17 calls registered Tarantool function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a Call17Request object + Do() instead. -func (p *ConnectionPool) Call17(functionName string, args interface{}, - userMode Mode) ([]interface{}, error) { - conn, err := p.getNextConnection(userMode) - if err != nil { - return nil, err - } - - return conn.Call17(functionName, args) -} - -// Eval passes lua expression for evaluation. -// -// Deprecated: the method will be removed in the next major version, -// use an EvalRequest object + Do() instead. -func (p *ConnectionPool) Eval(expr string, args interface{}, - userMode Mode) ([]interface{}, error) { - conn, err := p.getNextConnection(userMode) - if err != nil { - return nil, err - } - - return conn.Eval(expr, args) -} - -// Execute passes sql expression to Tarantool for execution. -// -// Deprecated: the method will be removed in the next major version, -// use an ExecuteRequest object + Do() instead. -func (p *ConnectionPool) Execute(expr string, args interface{}, - userMode Mode) ([]interface{}, error) { - conn, err := p.getNextConnection(userMode) - if err != nil { - return nil, err - } - - return conn.Execute(expr, args) -} - -// GetTyped performs select (with limit = 1 and offset = 0) -// to box space and fills typed result. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (p *ConnectionPool) GetTyped(space, index interface{}, key interface{}, result interface{}, - userMode ...Mode) error { - conn, err := p.getConnByMode(ANY, userMode) - if err != nil { - return err - } - - return conn.GetTyped(space, index, key, result) -} - -// SelectTyped performs select to box space and fills typed result. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (p *ConnectionPool) SelectTyped(space, index interface{}, - offset, limit uint32, - iterator tarantool.Iter, key interface{}, result interface{}, userMode ...Mode) error { - conn, err := p.getConnByMode(ANY, userMode) - if err != nil { - return err - } - - return conn.SelectTyped(space, index, offset, limit, iterator, key, result) -} - -// InsertTyped performs insertion to box space. -// Tarantool will reject Insert when tuple with same primary key exists. -// -// Deprecated: the method will be removed in the next major version, -// use an InsertRequest object + Do() instead. -func (p *ConnectionPool) InsertTyped(space interface{}, tuple interface{}, result interface{}, - userMode ...Mode) error { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return err - } - - return conn.InsertTyped(space, tuple, result) -} - -// ReplaceTyped performs "insert or replace" action to box space. -// If tuple with same primary key exists, it will be replaced. -// -// Deprecated: the method will be removed in the next major version, -// use a ReplaceRequest object + Do() instead. -func (p *ConnectionPool) ReplaceTyped(space interface{}, tuple interface{}, result interface{}, - userMode ...Mode) error { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return err - } - - return conn.ReplaceTyped(space, tuple, result) -} - -// DeleteTyped performs deletion of a tuple by key and fills result with deleted tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a DeleteRequest object + Do() instead. -func (p *ConnectionPool) DeleteTyped(space, index interface{}, key interface{}, result interface{}, - userMode ...Mode) error { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return err - } - - return conn.DeleteTyped(space, index, key, result) -} - -// UpdateTyped performs update of a tuple by key and fills result with updated tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a UpdateRequest object + Do() instead. -func (p *ConnectionPool) UpdateTyped(space, index interface{}, key interface{}, - ops *tarantool.Operations, result interface{}, userMode ...Mode) error { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return err - } - - return conn.UpdateTyped(space, index, key, ops, result) -} - -// CallTyped calls registered function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a CallRequest object + Do() instead. -func (p *ConnectionPool) CallTyped(functionName string, args interface{}, result interface{}, - userMode Mode) error { - conn, err := p.getNextConnection(userMode) - if err != nil { - return err - } - - return conn.CallTyped(functionName, args, result) -} - -// Call16Typed calls registered function. -// It uses request code for Tarantool 1.6, result is an array of arrays. -// Deprecated since Tarantool 1.7.2. -// -// Deprecated: the method will be removed in the next major version, -// use a Call16Request object + Do() instead. -func (p *ConnectionPool) Call16Typed(functionName string, args interface{}, result interface{}, - userMode Mode) error { - conn, err := p.getNextConnection(userMode) - if err != nil { - return err - } - - return conn.Call16Typed(functionName, args, result) -} - -// Call17Typed calls registered function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a Call17Request object + Do() instead. -func (p *ConnectionPool) Call17Typed(functionName string, args interface{}, result interface{}, - userMode Mode) error { - conn, err := p.getNextConnection(userMode) - if err != nil { - return err - } - - return conn.Call17Typed(functionName, args, result) -} - -// EvalTyped passes lua expression for evaluation. -// -// Deprecated: the method will be removed in the next major version, -// use an EvalRequest object + Do() instead. -func (p *ConnectionPool) EvalTyped(expr string, args interface{}, result interface{}, - userMode Mode) error { - conn, err := p.getNextConnection(userMode) - if err != nil { - return err - } - - return conn.EvalTyped(expr, args, result) -} - -// ExecuteTyped passes sql expression to Tarantool for execution. -// -// Deprecated: the method will be removed in the next major version, -// use an ExecuteRequest object + Do() instead. -func (p *ConnectionPool) ExecuteTyped(expr string, args interface{}, result interface{}, - userMode Mode) (tarantool.SQLInfo, []tarantool.ColumnMetaData, error) { - conn, err := p.getNextConnection(userMode) - if err != nil { - return tarantool.SQLInfo{}, nil, err - } - - return conn.ExecuteTyped(expr, args, result) -} - -// SelectAsync sends select request to Tarantool and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (p *ConnectionPool) SelectAsync(space, index interface{}, - offset, limit uint32, - iterator tarantool.Iter, key interface{}, userMode ...Mode) *tarantool.Future { - conn, err := p.getConnByMode(ANY, userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.SelectAsync(space, index, offset, limit, iterator, key) -} - -// InsertAsync sends insert action to Tarantool and returns Future. -// Tarantool will reject Insert when tuple with same primary key exists. -// -// Deprecated: the method will be removed in the next major version, -// use an InsertRequest object + Do() instead. -func (p *ConnectionPool) InsertAsync(space interface{}, tuple interface{}, - userMode ...Mode) *tarantool.Future { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.InsertAsync(space, tuple) -} - -// ReplaceAsync sends "insert or replace" action to Tarantool and returns Future. -// If tuple with same primary key exists, it will be replaced. -// -// Deprecated: the method will be removed in the next major version, -// use a ReplaceRequest object + Do() instead. -func (p *ConnectionPool) ReplaceAsync(space interface{}, tuple interface{}, - userMode ...Mode) *tarantool.Future { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.ReplaceAsync(space, tuple) -} - -// DeleteAsync sends deletion action to Tarantool and returns Future. -// Future's result will contain array with deleted tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a DeleteRequest object + Do() instead. -func (p *ConnectionPool) DeleteAsync(space, index interface{}, key interface{}, - userMode ...Mode) *tarantool.Future { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.DeleteAsync(space, index, key) -} - -// UpdateAsync sends deletion of a tuple by key and returns Future. -// Future's result will contain array with updated tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a UpdateRequest object + Do() instead. -func (p *ConnectionPool) UpdateAsync(space, index interface{}, key interface{}, - ops *tarantool.Operations, userMode ...Mode) *tarantool.Future { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.UpdateAsync(space, index, key, ops) -} - -// UpsertAsync sends "update or insert" action to Tarantool and returns Future. -// Future's sesult will not contain any tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a UpsertRequest object + Do() instead. -func (p *ConnectionPool) UpsertAsync(space interface{}, tuple interface{}, - ops *tarantool.Operations, userMode ...Mode) *tarantool.Future { - conn, err := p.getConnByMode(RW, userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.UpsertAsync(space, tuple, ops) -} - -// CallAsync sends a call to registered Tarantool function and returns Future. -// It uses request code for Tarantool >= 1.7, future's result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a CallRequest object + Do() instead. -func (p *ConnectionPool) CallAsync(functionName string, args interface{}, - userMode Mode) *tarantool.Future { - conn, err := p.getNextConnection(userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.CallAsync(functionName, args) -} - -// Call16Async sends a call to registered Tarantool function and returns Future. -// It uses request code for Tarantool 1.6, so future's result is an array of arrays. -// Deprecated since Tarantool 1.7.2. -// -// Deprecated: the method will be removed in the next major version, -// use a Call16Request object + Do() instead. -func (p *ConnectionPool) Call16Async(functionName string, args interface{}, - userMode Mode) *tarantool.Future { - conn, err := p.getNextConnection(userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.Call16Async(functionName, args) -} - -// Call17Async sends a call to registered Tarantool function and returns Future. -// It uses request code for Tarantool >= 1.7, future's result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a Call17Request object + Do() instead. -func (p *ConnectionPool) Call17Async(functionName string, args interface{}, - userMode Mode) *tarantool.Future { - conn, err := p.getNextConnection(userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.Call17Async(functionName, args) -} - -// EvalAsync sends a lua expression for evaluation and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use an EvalRequest object + Do() instead. -func (p *ConnectionPool) EvalAsync(expr string, args interface{}, - userMode Mode) *tarantool.Future { - conn, err := p.getNextConnection(userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.EvalAsync(expr, args) -} - -// ExecuteAsync sends sql expression to Tarantool for execution and returns -// Future. -// -// Deprecated: the method will be removed in the next major version, -// use an ExecuteRequest object + Do() instead. -func (p *ConnectionPool) ExecuteAsync(expr string, args interface{}, - userMode Mode) *tarantool.Future { - conn, err := p.getNextConnection(userMode) - if err != nil { - return newErrorFuture(err) - } - - return conn.ExecuteAsync(expr, args) -} - // NewStream creates new Stream object for connection selected // by userMode from pool. // @@ -1514,20 +1010,6 @@ func (p *ConnectionPool) getNextConnection(mode Mode) (*tarantool.Connection, er return nil, ErrNoHealthyInstance } -func (p *ConnectionPool) getConnByMode(defaultMode Mode, - userMode []Mode) (*tarantool.Connection, error) { - if len(userMode) > 1 { - return nil, ErrTooManyArgs - } - - mode := defaultMode - if len(userMode) > 0 { - mode = userMode[0] - } - - return p.getNextConnection(mode) -} - func newErrorFuture(err error) *tarantool.Future { fut := tarantool.NewFuture(nil) fut.SetError(err) diff --git a/pool/connection_pool_test.go b/pool/connection_pool_test.go index e0fcc8c47..f4a0376d4 100644 --- a/pool/connection_pool_test.go +++ b/pool/connection_pool_test.go @@ -1130,9 +1130,11 @@ func TestConnectionHandlerOpenUpdateClose(t *testing.T) { require.Nilf(t, err, "failed to connect") require.NotNilf(t, connPool, "conn is nil after Connect") - _, err = connPool.Call17("box.cfg", []interface{}{map[string]bool{ - "read_only": true, - }}, pool.RW) + _, err = connPool.Do(tarantool.NewCall17Request("box.cfg"). + Args([]interface{}{map[string]bool{ + "read_only": true, + }}), + pool.RW).GetResponse() require.Nilf(t, err, "failed to make ro") for i := 0; i < 100; i++ { @@ -1271,9 +1273,10 @@ func TestConnectionHandlerUpdateError(t *testing.T) { require.Truef(t, connected, "should be connected") for i := 0; i < len(poolServers); i++ { - _, err = connPool.Call17("box.cfg", []interface{}{map[string]bool{ - "read_only": true, - }}, pool.RW) + _, err = connPool.Do(tarantool.NewCall17Request("box.cfg"). + Args([]interface{}{map[string]bool{ + "read_only": true, + }}), pool.RW).Get() require.Nilf(t, err, "failed to make ro") } @@ -1403,8 +1406,8 @@ func TestRequestOnClosed(t *testing.T) { defaultCountRetry, defaultTimeoutRetry) require.Nil(t, err) - _, err = connPool.Ping(pool.ANY) - require.NotNilf(t, err, "err is nil after Ping") + _, err = connPool.Do(tarantool.NewPingRequest(), pool.ANY).Get() + require.NotNilf(t, err, "err is nil after Do with PingRequest") err = test_helpers.RestartTarantool(helpInstances[0]) require.Nilf(t, err, "failed to restart tarantool") @@ -1413,7 +1416,7 @@ func TestRequestOnClosed(t *testing.T) { require.Nilf(t, err, "failed to restart tarantool") } -func TestCall(t *testing.T) { +func TestDoWithCallRequest(t *testing.T) { roles := []bool{false, true, false, false, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -1429,10 +1432,13 @@ func TestCall(t *testing.T) { defer connPool.Close() // PreferRO - data, err := connPool.Call("box.info", []interface{}{}, pool.PreferRO) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err := connPool.Do( + tarantool.NewCallRequest("box.info"). + Args([]interface{}{}), + pool.PreferRO).Get() + require.Nilf(t, err, "failed to Do with CallRequest") + require.NotNilf(t, data, "response is nil after Do with CallRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with CallRequest") val := data[0].(map[interface{}]interface{})["ro"] ro, ok := val.(bool) @@ -1440,10 +1446,13 @@ func TestCall(t *testing.T) { require.Truef(t, ro, "expected `true` with mode `PreferRO`") // PreferRW - data, err = connPool.Call("box.info", []interface{}{}, pool.PreferRW) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCallRequest("box.info"). + Args([]interface{}{}), + pool.PreferRW).Get() + require.Nilf(t, err, "failed to Do with CallRequest") + require.NotNilf(t, data, "response is nil after Do with CallRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with CallRequest") val = data[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1451,10 +1460,13 @@ func TestCall(t *testing.T) { require.Falsef(t, ro, "expected `false` with mode `PreferRW`") // RO - data, err = connPool.Call("box.info", []interface{}{}, pool.RO) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCallRequest("box.info"). + Args([]interface{}{}), + pool.RO).Get() + require.Nilf(t, err, "failed to Do with CallRequest") + require.NotNilf(t, data, "response is nil after Do with CallRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with CallRequest") val = data[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1462,10 +1474,13 @@ func TestCall(t *testing.T) { require.Truef(t, ro, "expected `true` with mode `RO`") // RW - data, err = connPool.Call("box.info", []interface{}{}, pool.RW) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCallRequest("box.info"). + Args([]interface{}{}), + pool.RW).Get() + require.Nilf(t, err, "failed to Do with CallRequest") + require.NotNilf(t, data, "response is nil after Do with CallRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with CallRequest") val = data[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1473,7 +1488,7 @@ func TestCall(t *testing.T) { require.Falsef(t, ro, "expected `false` with mode `RW`") } -func TestCall16(t *testing.T) { +func TestDoWithCall16Request(t *testing.T) { roles := []bool{false, true, false, false, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -1489,10 +1504,13 @@ func TestCall16(t *testing.T) { defer connPool.Close() // PreferRO - data, err := connPool.Call16("box.info", []interface{}{}, pool.PreferRO) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err := connPool.Do( + tarantool.NewCall16Request("box.info"). + Args([]interface{}{}), + pool.PreferRO).Get() + require.Nilf(t, err, "failed to Do with Call16Request") + require.NotNilf(t, data, "response is nil after Do with Call16Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call16Request") val := data[0].([]interface{})[0].(map[interface{}]interface{})["ro"] ro, ok := val.(bool) @@ -1500,10 +1518,13 @@ func TestCall16(t *testing.T) { require.Truef(t, ro, "expected `true` with mode `PreferRO`") // PreferRW - data, err = connPool.Call16("box.info", []interface{}{}, pool.PreferRW) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCall16Request("box.info"). + Args([]interface{}{}), + pool.PreferRW).Get() + require.Nilf(t, err, "failed to Do with Call16Request") + require.NotNilf(t, data, "response is nil after Do with Call16Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call16Request") val = data[0].([]interface{})[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1511,10 +1532,13 @@ func TestCall16(t *testing.T) { require.Falsef(t, ro, "expected `false` with mode `PreferRW`") // RO - data, err = connPool.Call16("box.info", []interface{}{}, pool.RO) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCall16Request("box.info"). + Args([]interface{}{}), + pool.RO).Get() + require.Nilf(t, err, "failed to Do with Call16Request") + require.NotNilf(t, data, "response is nil after Do with Call16Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call16Request") val = data[0].([]interface{})[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1522,10 +1546,13 @@ func TestCall16(t *testing.T) { require.Truef(t, ro, "expected `true` with mode `RO`") // RW - data, err = connPool.Call16("box.info", []interface{}{}, pool.RW) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCall16Request("box.info"). + Args([]interface{}{}), + pool.RW).Get() + require.Nilf(t, err, "failed to Do with Call16Request") + require.NotNilf(t, data, "response is nil after Do with Call16Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call16Request") val = data[0].([]interface{})[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1533,7 +1560,7 @@ func TestCall16(t *testing.T) { require.Falsef(t, ro, "expected `false` with mode `RW`") } -func TestCall17(t *testing.T) { +func TestDoWithCall17Request(t *testing.T) { roles := []bool{false, true, false, false, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -1549,10 +1576,13 @@ func TestCall17(t *testing.T) { defer connPool.Close() // PreferRO - data, err := connPool.Call17("box.info", []interface{}{}, pool.PreferRO) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err := connPool.Do( + tarantool.NewCall17Request("box.info"). + Args([]interface{}{}), + pool.PreferRO).Get() + require.Nilf(t, err, "failed to Do with Call17Request") + require.NotNilf(t, data, "response is nil after Do with Call17Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call17Request") val := data[0].(map[interface{}]interface{})["ro"] ro, ok := val.(bool) @@ -1560,10 +1590,13 @@ func TestCall17(t *testing.T) { require.Truef(t, ro, "expected `true` with mode `PreferRO`") // PreferRW - data, err = connPool.Call17("box.info", []interface{}{}, pool.PreferRW) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCall17Request("box.info"). + Args([]interface{}{}), + pool.PreferRW).Get() + require.Nilf(t, err, "failed to Do with Call17Request") + require.NotNilf(t, data, "response is nil after Do with Call17Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call17Request") val = data[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1571,10 +1604,13 @@ func TestCall17(t *testing.T) { require.Falsef(t, ro, "expected `false` with mode `PreferRW`") // RO - data, err = connPool.Call17("box.info", []interface{}{}, pool.RO) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCall17Request("box.info"). + Args([]interface{}{}), + pool.RO).Get() + require.Nilf(t, err, "failed to Do with Call17Request") + require.NotNilf(t, data, "response is nil after Do with Call17Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call17Request") val = data[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1582,10 +1618,13 @@ func TestCall17(t *testing.T) { require.Truef(t, ro, "expected `true` with mode `RO`") // RW - data, err = connPool.Call17("box.info", []interface{}{}, pool.RW) - require.Nilf(t, err, "failed to Call") - require.NotNilf(t, data, "response is nil after Call") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Call") + data, err = connPool.Do( + tarantool.NewCall17Request("box.info"). + Args([]interface{}{}), + pool.RW).Get() + require.Nilf(t, err, "failed to Do with Call17Request") + require.NotNilf(t, data, "response is nil after Do with Call17Request") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with Call17Request") val = data[0].(map[interface{}]interface{})["ro"] ro, ok = val.(bool) @@ -1593,7 +1632,7 @@ func TestCall17(t *testing.T) { require.Falsef(t, ro, "expected `false` with mode `RW`") } -func TestEval(t *testing.T) { +func TestDoWithEvalRequest(t *testing.T) { roles := []bool{false, true, false, false, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -1609,40 +1648,52 @@ func TestEval(t *testing.T) { defer connPool.Close() // PreferRO - data, err := connPool.Eval("return box.info().ro", []interface{}{}, pool.PreferRO) - require.Nilf(t, err, "failed to Eval") - require.NotNilf(t, data, "response is nil after Eval") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Eval") + data, err := connPool.Do( + tarantool.NewEvalRequest("return box.info().ro"). + Args([]interface{}{}), + pool.PreferRO).Get() + require.Nilf(t, err, "failed to Do with EvalRequest") + require.NotNilf(t, data, "response is nil after Do with EvalRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with EvalRequest") val, ok := data[0].(bool) require.Truef(t, ok, "expected `true` with mode `PreferRO`") require.Truef(t, val, "expected `true` with mode `PreferRO`") // PreferRW - data, err = connPool.Eval("return box.info().ro", []interface{}{}, pool.PreferRW) - require.Nilf(t, err, "failed to Eval") - require.NotNilf(t, data, "response is nil after Eval") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Eval") + data, err = connPool.Do( + tarantool.NewEvalRequest("return box.info().ro"). + Args([]interface{}{}), + pool.PreferRW).Get() + require.Nilf(t, err, "failed to Do with EvalRequest") + require.NotNilf(t, data, "response is nil after Do with EvalRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with EvalRequest") val, ok = data[0].(bool) require.Truef(t, ok, "expected `false` with mode `PreferRW`") require.Falsef(t, val, "expected `false` with mode `PreferRW`") // RO - data, err = connPool.Eval("return box.info().ro", []interface{}{}, pool.RO) - require.Nilf(t, err, "failed to Eval") - require.NotNilf(t, data, "response is nil after Eval") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Eval") + data, err = connPool.Do( + tarantool.NewEvalRequest("return box.info().ro"). + Args([]interface{}{}), + pool.RO).Get() + require.Nilf(t, err, "failed to Do with EvalRequest") + require.NotNilf(t, data, "response is nil after Do with EvalRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with EvalRequest") val, ok = data[0].(bool) require.Truef(t, ok, "expected `true` with mode `RO`") require.Truef(t, val, "expected `true` with mode `RO`") // RW - data, err = connPool.Eval("return box.info().ro", []interface{}{}, pool.RW) - require.Nilf(t, err, "failed to Eval") - require.NotNilf(t, data, "response is nil after Eval") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Eval") + data, err = connPool.Do( + tarantool.NewEvalRequest("return box.info().ro"). + Args([]interface{}{}), + pool.RW).Get() + require.Nilf(t, err, "failed to Do with EvalRequest") + require.NotNilf(t, data, "response is nil after Do with EvalRequest") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with EvalRequest") val, ok = data[0].(bool) require.Truef(t, ok, "expected `false` with mode `RW`") @@ -1672,7 +1723,7 @@ func (m *Member) DecodeMsgpack(d *msgpack.Decoder) error { return nil } -func TestExecute(t *testing.T) { +func TestDoWithExecuteRequest(t *testing.T) { test_helpers.SkipIfSQLUnsupported(t) roles := []bool{false, true, false, false, true} @@ -1690,26 +1741,17 @@ func TestExecute(t *testing.T) { defer connPool.Close() request := "SELECT NAME0, NAME1 FROM SQL_TEST WHERE NAME0 == 1;" - // Execute - data, err := connPool.Execute(request, []interface{}{}, pool.ANY) - require.Nilf(t, err, "failed to Execute") - require.NotNilf(t, data, "response is nil after Execute") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Execute") - require.Equalf(t, len(data[0].([]interface{})), 2, "unexpected response") - - // ExecuteTyped mem := []Member{} - info, _, err := connPool.ExecuteTyped(request, []interface{}{}, &mem, pool.ANY) - require.Nilf(t, err, "failed to ExecuteTyped") - require.Equalf(t, info.AffectedCount, uint64(0), "unexpected info.AffectedCount") - require.Equalf(t, len(mem), 1, "wrong count of results") - - // ExecuteAsync - fut := connPool.ExecuteAsync(request, []interface{}{}, pool.ANY) - data, err = fut.Get() - require.Nilf(t, err, "failed to ExecuteAsync") - require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after ExecuteAsync") + + fut := connPool.Do(tarantool.NewExecuteRequest(request).Args([]interface{}{}), pool.ANY) + data, err := fut.Get() + require.Nilf(t, err, "failed to Do with ExecuteRequest") + require.NotNilf(t, data, "response is nil after Execute") + require.GreaterOrEqualf(t, len(data), 1, "response.Data is empty after Do with ExecuteRequest") require.Equalf(t, len(data[0].([]interface{})), 2, "unexpected response") + err = fut.GetTyped(&mem) + require.Nilf(t, err, "Unable to GetTyped of fut") + require.Equalf(t, len(mem), 1, "wrong count of result") } func TestRoundRobinStrategy(t *testing.T) { @@ -1829,8 +1871,11 @@ func TestRoundRobinStrategy_NoReplica(t *testing.T) { defer connPool.Close() // RO - _, err = connPool.Eval("return box.cfg.listen", []interface{}{}, pool.RO) - require.NotNilf(t, err, "expected to fail after Eval, but error is nil") + _, err = connPool.Do( + tarantool.NewEvalRequest("return box.cfg.listen"). + Args([]interface{}{}), + pool.RO).Get() + require.NotNilf(t, err, "expected to fail after Do with EvalRequest, but error is nil") require.Equal(t, "can't find ro instance in pool", err.Error()) // ANY @@ -1903,8 +1948,11 @@ func TestRoundRobinStrategy_NoMaster(t *testing.T) { defer connPool.Close() // RW - _, err = connPool.Eval("return box.cfg.listen", []interface{}{}, pool.RW) - require.NotNilf(t, err, "expected to fail after Eval, but error is nil") + _, err = connPool.Do( + tarantool.NewEvalRequest("return box.cfg.listen"). + Args([]interface{}{}), + pool.RW).Get() + require.NotNilf(t, err, "expected to fail after Do with EvalRequest, but error is nil") require.Equal(t, "can't find rw instance in pool", err.Error()) // ANY @@ -2122,7 +2170,7 @@ func TestUpdateInstancesRoles(t *testing.T) { require.Nil(t, err) } -func TestInsert(t *testing.T) { +func TestDoWithInsertRequest(t *testing.T) { roles := []bool{true, true, false, true, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -2137,8 +2185,10 @@ func TestInsert(t *testing.T) { defer connPool.Close() - // Mode is `RW` by default, we have only one RW instance (servers[2]) - data, err := connPool.Insert(spaceName, []interface{}{"rw_insert_key", "rw_insert_value"}) + // RW + data, err := connPool.Do(tarantool.NewInsertRequest(spaceName). + Tuple([]interface{}{"rw_insert_key", "rw_insert_value"}), + pool.RW).Get() require.Nilf(t, err, "failed to Insert") require.NotNilf(t, data, "response is nil after Insert") require.Equalf(t, len(data), 1, "response Body len != 1 after Insert") @@ -2182,8 +2232,8 @@ func TestInsert(t *testing.T) { require.Equalf(t, "rw_insert_value", value, "unexpected body of Select (1)") // PreferRW - data, err = connPool.Insert(spaceName, - []interface{}{"preferRW_insert_key", "preferRW_insert_value"}) + data, err = connPool.Do(tarantool.NewInsertRequest(spaceName).Tuple( + []interface{}{"preferRW_insert_key", "preferRW_insert_value"}), pool.PreferRW).Get() require.Nilf(t, err, "failed to Insert") require.NotNilf(t, data, "response is nil after Insert") require.Equalf(t, len(data), 1, "response Body len != 1 after Insert") @@ -2222,7 +2272,7 @@ func TestInsert(t *testing.T) { require.Equalf(t, "preferRW_insert_value", value, "unexpected body of Select (1)") } -func TestDelete(t *testing.T) { +func TestDoWithDeleteRequest(t *testing.T) { roles := []bool{true, true, false, true, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -2259,23 +2309,26 @@ func TestDelete(t *testing.T) { require.Truef(t, ok, "unexpected body of Insert (1)") require.Equalf(t, "delete_value", value, "unexpected body of Insert (1)") - // Mode is `RW` by default, we have only one RW instance (servers[2]) - data, err = connPool.Delete(spaceName, indexNo, []interface{}{"delete_key"}) - require.Nilf(t, err, "failed to Delete") - require.NotNilf(t, data, "response is nil after Delete") - require.Equalf(t, len(data), 1, "response Body len != 1 after Delete") + data, err = connPool.Do( + tarantool.NewDeleteRequest(spaceName). + Index(indexNo). + Key([]interface{}{"delete_key"}), + pool.RW).Get() + require.Nilf(t, err, "failed to Do with DeleteRequest") + require.NotNilf(t, data, "response is nil after Do with DeleteRequest") + require.Equalf(t, len(data), 1, "response Body len != 1 after Do with DeleteRequest") tpl, ok = data[0].([]interface{}) - require.Truef(t, ok, "unexpected body of Delete") - require.Equalf(t, 2, len(tpl), "unexpected body of Delete") + require.Truef(t, ok, "unexpected body of Do with DeleteRequest") + require.Equalf(t, 2, len(tpl), "unexpected body of Do with DeleteRequest") key, ok = tpl[0].(string) - require.Truef(t, ok, "unexpected body of Delete (0)") - require.Equalf(t, "delete_key", key, "unexpected body of Delete (0)") + require.Truef(t, ok, "unexpected body of Do with DeleteRequest (0)") + require.Equalf(t, "delete_key", key, "unexpected body of Do with DeleteRequest (0)") value, ok = tpl[1].(string) - require.Truef(t, ok, "unexpected body of Delete (1)") - require.Equalf(t, "delete_value", value, "unexpected body of Delete (1)") + require.Truef(t, ok, "unexpected body of Do with DeleteRequest (1)") + require.Equalf(t, "delete_value", value, "unexpected body of Do with DeleteRequest (1)") sel := tarantool.NewSelectRequest(spaceNo). Index(indexNo). @@ -2287,7 +2340,7 @@ func TestDelete(t *testing.T) { require.Equalf(t, 0, len(data), "response Body len != 0 after Select") } -func TestUpsert(t *testing.T) { +func TestDoWithUpsertRequest(t *testing.T) { roles := []bool{true, true, false, true, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -2307,10 +2360,10 @@ func TestUpsert(t *testing.T) { conn := test_helpers.ConnectWithValidation(t, makeDialer(servers[2]), connOpts) defer conn.Close() - // Mode is `RW` by default, we have only one RW instance (servers[2]) - data, err := connPool.Upsert(spaceName, - []interface{}{"upsert_key", "upsert_value"}, - tarantool.NewOperations().Assign(1, "new_value")) + // RW + data, err := connPool.Do(tarantool.NewUpsertRequest(spaceName).Tuple( + []interface{}{"upsert_key", "upsert_value"}).Operations( + tarantool.NewOperations().Assign(1, "new_value")), pool.RW).Get() require.Nilf(t, err, "failed to Upsert") require.NotNilf(t, data, "response is nil after Upsert") @@ -2336,9 +2389,9 @@ func TestUpsert(t *testing.T) { require.Equalf(t, "upsert_value", value, "unexpected body of Select (1)") // PreferRW - data, err = connPool.Upsert( - spaceName, []interface{}{"upsert_key", "upsert_value"}, - tarantool.NewOperations().Assign(1, "new_value"), pool.PreferRW) + data, err = connPool.Do(tarantool.NewUpsertRequest( + spaceName).Tuple([]interface{}{"upsert_key", "upsert_value"}).Operations( + tarantool.NewOperations().Assign(1, "new_value")), pool.PreferRW).Get() require.Nilf(t, err, "failed to Upsert") require.NotNilf(t, data, "response is nil after Upsert") @@ -2360,7 +2413,7 @@ func TestUpsert(t *testing.T) { require.Equalf(t, "new_value", value, "unexpected body of Select (1)") } -func TestUpdate(t *testing.T) { +func TestDoWithUpdateRequest(t *testing.T) { roles := []bool{true, true, false, true, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -2398,9 +2451,12 @@ func TestUpdate(t *testing.T) { require.Truef(t, ok, "unexpected body of Insert (1)") require.Equalf(t, "update_value", value, "unexpected body of Insert (1)") - // Mode is `RW` by default, we have only one RW instance (servers[2]) - resp, err := connPool.Update(spaceName, indexNo, - []interface{}{"update_key"}, tarantool.NewOperations().Assign(1, "new_value")) + // RW + resp, err := connPool.Do(tarantool.NewUpdateRequest(spaceName). + Index(indexNo). + Key([]interface{}{"update_key"}). + Operations(tarantool.NewOperations().Assign(1, "new_value")), + pool.RW).Get() require.Nilf(t, err, "failed to Update") require.NotNilf(t, resp, "response is nil after Update") @@ -2426,9 +2482,11 @@ func TestUpdate(t *testing.T) { require.Equalf(t, "new_value", value, "unexpected body of Select (1)") // PreferRW - resp, err = connPool.Update( - spaceName, indexNo, []interface{}{"update_key"}, - tarantool.NewOperations().Assign(1, "another_value"), pool.PreferRW) + resp, err = connPool.Do(tarantool.NewUpdateRequest(spaceName). + Index(indexNo). + Key([]interface{}{"update_key"}). + Operations(tarantool.NewOperations().Assign(1, "another_value")), + pool.PreferRW).Get() require.Nilf(t, err, "failed to Update") require.NotNilf(t, resp, "response is nil after Update") @@ -2450,7 +2508,7 @@ func TestUpdate(t *testing.T) { require.Equalf(t, "another_value", value, "unexpected body of Select (1)") } -func TestReplace(t *testing.T) { +func TestDoWithReplaceRequest(t *testing.T) { roles := []bool{true, true, false, true, true} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -2488,10 +2546,12 @@ func TestReplace(t *testing.T) { require.Truef(t, ok, "unexpected body of Insert (1)") require.Equalf(t, "replace_value", value, "unexpected body of Insert (1)") - // Mode is `RW` by default, we have only one RW instance (servers[2]) - resp, err := connPool.Replace(spaceNo, []interface{}{"new_key", "new_value"}) - require.Nilf(t, err, "failed to Replace") - require.NotNilf(t, resp, "response is nil after Replace") + // RW + resp, err := connPool.Do(tarantool.NewReplaceRequest(spaceNo). + Tuple([]interface{}{"new_key", "new_value"}), + pool.RW).Get() + require.Nilf(t, err, "failed to Do with ReplaceRequest") + require.NotNilf(t, resp, "response is nil after Do with ReplaceRequest") sel := tarantool.NewSelectRequest(spaceNo). Index(indexNo). @@ -2515,9 +2575,11 @@ func TestReplace(t *testing.T) { require.Equalf(t, "new_value", value, "unexpected body of Select (1)") // PreferRW - resp, err = connPool.Replace(spaceNo, []interface{}{"new_key", "new_value"}, pool.PreferRW) - require.Nilf(t, err, "failed to Replace") - require.NotNilf(t, resp, "response is nil after Replace") + resp, err = connPool.Do(tarantool.NewReplaceRequest(spaceNo). + Tuple([]interface{}{"new_key", "new_value"}), + pool.PreferRW).Get() + require.Nilf(t, err, "failed to Do with ReplaceRequest") + require.NotNilf(t, resp, "response is nil after Do with ReplaceRequest") data, err = conn.Do(sel).Get() require.Nilf(t, err, "failed to Select") @@ -2536,7 +2598,7 @@ func TestReplace(t *testing.T) { require.Equalf(t, "new_value", value, "unexpected body of Select (1)") } -func TestSelect(t *testing.T) { +func TestDoWithSelectRequest(t *testing.T) { roles := []bool{true, true, false, true, false} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -2572,94 +2634,124 @@ func TestSelect(t *testing.T) { err = test_helpers.InsertOnInstances(ctx, makeDialers(allServers), connOpts, spaceNo, anyTpl) require.Nil(t, err) - // default: ANY - data, err := connPool.Select(spaceNo, indexNo, 0, 1, tarantool.IterEq, anyKey) - require.Nilf(t, err, "failed to Select") - require.NotNilf(t, data, "response is nil after Select") - require.Equalf(t, len(data), 1, "response Body len != 1 after Select") + // ANY + data, err := connPool.Do(tarantool.NewSelectRequest(spaceNo). + Index(indexNo). + Offset(0). + Limit(1). + Iterator(tarantool.IterEq). + Key(anyKey), + pool.ANY).Get() + require.Nilf(t, err, "failed to Do with SelectRequest") + require.NotNilf(t, data, "response is nil after Do with SelectRequest") + require.Equalf(t, len(data), 1, "response Body len != 1 after Do with SelectRequest") tpl, ok := data[0].([]interface{}) - require.Truef(t, ok, "unexpected body of Select") - require.Equalf(t, 2, len(tpl), "unexpected body of Select") + require.Truef(t, ok, "unexpected body of Do with SelectRequest") + require.Equalf(t, 2, len(tpl), "unexpected body of Do with SelectRequest") key, ok := tpl[0].(string) - require.Truef(t, ok, "unexpected body of Select (0)") - require.Equalf(t, "any_select_key", key, "unexpected body of Select (0)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (0)") + require.Equalf(t, "any_select_key", key, "unexpected body of Do with SelectRequest (0)") value, ok := tpl[1].(string) - require.Truef(t, ok, "unexpected body of Select (1)") - require.Equalf(t, "any_select_value", value, "unexpected body of Select (1)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (1)") + require.Equalf(t, "any_select_value", value, "unexpected body of Do with SelectRequest (1)") // PreferRO - data, err = connPool.Select(spaceNo, indexNo, 0, 1, tarantool.IterEq, roKey, pool.PreferRO) - require.Nilf(t, err, "failed to Select") - require.NotNilf(t, data, "response is nil after Select") - require.Equalf(t, len(data), 1, "response Body len != 1 after Select") + data, err = connPool.Do(tarantool.NewSelectRequest(spaceNo). + Index(indexNo). + Offset(0). + Limit(1). + Iterator(tarantool.IterEq). + Key(roKey), + pool.PreferRO).Get() + require.Nilf(t, err, "failed to Do with SelectRequest") + require.NotNilf(t, data, "response is nil after Do with SelectRequest") + require.Equalf(t, len(data), 1, "response Body len != 1 after Do with SelectRequest") tpl, ok = data[0].([]interface{}) - require.Truef(t, ok, "unexpected body of Select") - require.Equalf(t, 2, len(tpl), "unexpected body of Select") + require.Truef(t, ok, "unexpected body of Do with SelectRequest") + require.Equalf(t, 2, len(tpl), "unexpected body of Do with SelectRequest") key, ok = tpl[0].(string) - require.Truef(t, ok, "unexpected body of Select (0)") - require.Equalf(t, "ro_select_key", key, "unexpected body of Select (0)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (0)") + require.Equalf(t, "ro_select_key", key, "unexpected body of Do with SelectRequest (0)") // PreferRW - data, err = connPool.Select(spaceNo, indexNo, 0, 1, tarantool.IterEq, rwKey, pool.PreferRW) - require.Nilf(t, err, "failed to Select") - require.NotNilf(t, data, "response is nil after Select") - require.Equalf(t, len(data), 1, "response Body len != 1 after Select") + data, err = connPool.Do(tarantool.NewSelectRequest(spaceNo). + Index(indexNo). + Offset(0). + Limit(1). + Iterator(tarantool.IterEq). + Key(rwKey), + pool.PreferRW).Get() + require.Nilf(t, err, "failed to Do with SelectRequest") + require.NotNilf(t, data, "response is nil after Do with SelectRequest") + require.Equalf(t, len(data), 1, "response Body len != 1 after Do with SelectRequest") tpl, ok = data[0].([]interface{}) - require.Truef(t, ok, "unexpected body of Select") - require.Equalf(t, 2, len(tpl), "unexpected body of Select") + require.Truef(t, ok, "unexpected body of Do with SelectRequest") + require.Equalf(t, 2, len(tpl), "unexpected body of Do with SelectRequest") key, ok = tpl[0].(string) - require.Truef(t, ok, "unexpected body of Select (0)") - require.Equalf(t, "rw_select_key", key, "unexpected body of Select (0)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (0)") + require.Equalf(t, "rw_select_key", key, "unexpected body of Do with SelectRequest (0)") value, ok = tpl[1].(string) - require.Truef(t, ok, "unexpected body of Select (1)") - require.Equalf(t, "rw_select_value", value, "unexpected body of Select (1)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (1)") + require.Equalf(t, "rw_select_value", value, "unexpected body of Do with SelectRequest (1)") // RO - data, err = connPool.Select(spaceNo, indexNo, 0, 1, tarantool.IterEq, roKey, pool.RO) - require.Nilf(t, err, "failed to Select") - require.NotNilf(t, data, "response is nil after Select") - require.Equalf(t, len(data), 1, "response Body len != 1 after Select") + data, err = connPool.Do(tarantool.NewSelectRequest(spaceNo). + Index(indexNo). + Offset(0). + Limit(1). + Iterator(tarantool.IterEq). + Key(roKey), + pool.RO).Get() + require.Nilf(t, err, "failed to Do with SelectRequest") + require.NotNilf(t, data, "response is nil after Do with SelectRequest") + require.Equalf(t, len(data), 1, "response Body len != 1 after Do with SelectRequest") tpl, ok = data[0].([]interface{}) - require.Truef(t, ok, "unexpected body of Select") - require.Equalf(t, 2, len(tpl), "unexpected body of Select") + require.Truef(t, ok, "unexpected body of Do with SelectRequest") + require.Equalf(t, 2, len(tpl), "unexpected body of Do with SelectRequest") key, ok = tpl[0].(string) - require.Truef(t, ok, "unexpected body of Select (0)") - require.Equalf(t, "ro_select_key", key, "unexpected body of Select (0)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (0)") + require.Equalf(t, "ro_select_key", key, "unexpected body of Do with SelectRequest (0)") value, ok = tpl[1].(string) - require.Truef(t, ok, "unexpected body of Select (1)") - require.Equalf(t, "ro_select_value", value, "unexpected body of Select (1)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (1)") + require.Equalf(t, "ro_select_value", value, "unexpected body of Do with SelectRequest (1)") // RW - data, err = connPool.Select(spaceNo, indexNo, 0, 1, tarantool.IterEq, rwKey, pool.RW) - require.Nilf(t, err, "failed to Select") - require.NotNilf(t, data, "response is nil after Select") - require.Equalf(t, len(data), 1, "response Body len != 1 after Select") + data, err = connPool.Do(tarantool.NewSelectRequest(spaceNo). + Index(indexNo). + Offset(0). + Limit(1). + Iterator(tarantool.IterEq). + Key(rwKey), + pool.RW).Get() + require.Nilf(t, err, "failed to Do with SelectRequest") + require.NotNilf(t, data, "response is nil after Do with SelectRequest") + require.Equalf(t, len(data), 1, "response Body len != 1 after Do with SelectRequest") tpl, ok = data[0].([]interface{}) - require.Truef(t, ok, "unexpected body of Select") - require.Equalf(t, 2, len(tpl), "unexpected body of Select") + require.Truef(t, ok, "unexpected body of Do with SelectRequest") + require.Equalf(t, 2, len(tpl), "unexpected body of Do with SelectRequest") key, ok = tpl[0].(string) - require.Truef(t, ok, "unexpected body of Select (0)") - require.Equalf(t, "rw_select_key", key, "unexpected body of Select (0)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (0)") + require.Equalf(t, "rw_select_key", key, "unexpected body of Do with SelectRequest (0)") value, ok = tpl[1].(string) - require.Truef(t, ok, "unexpected body of Select (1)") - require.Equalf(t, "rw_select_value", value, "unexpected body of Select (1)") + require.Truef(t, ok, "unexpected body of Do with SelectRequest (1)") + require.Equalf(t, "rw_select_value", value, "unexpected body of Do with SelectRequest (1)") } -func TestPing(t *testing.T) { +func TestDoWithPingRequest(t *testing.T) { roles := []bool{true, true, false, true, false} ctx, cancel := test_helpers.GetPoolConnectContext() @@ -2675,28 +2767,28 @@ func TestPing(t *testing.T) { defer connPool.Close() // ANY - data, err := connPool.Ping(pool.ANY) - require.Nilf(t, err, "failed to Ping") - require.Nilf(t, data, "response data is not nil after Ping") + data, err := connPool.Do(tarantool.NewPingRequest(), pool.ANY).Get() + require.Nilf(t, err, "failed to Do with Ping Request") + require.Nilf(t, data, "response data is not nil after Do with Ping Request") // RW - data, err = connPool.Ping(pool.RW) - require.Nilf(t, err, "failed to Ping") - require.Nilf(t, data, "response data is not nil after Ping") + data, err = connPool.Do(tarantool.NewPingRequest(), pool.RW).Get() + require.Nilf(t, err, "failed to Do with Ping Request") + require.Nilf(t, data, "response data is not nil after Do with Ping Request") // RO - _, err = connPool.Ping(pool.RO) - require.Nilf(t, err, "failed to Ping") + _, err = connPool.Do(tarantool.NewPingRequest(), pool.RO).Get() + require.Nilf(t, err, "failed to Do with Ping Request") // PreferRW - data, err = connPool.Ping(pool.PreferRW) - require.Nilf(t, err, "failed to Ping") - require.Nilf(t, data, "response data is not nil after Ping") + data, err = connPool.Do(tarantool.NewPingRequest(), pool.PreferRW).Get() + require.Nilf(t, err, "failed to Do with Ping Request") + require.Nilf(t, data, "response data is not nil after Do with Ping Request") // PreferRO - data, err = connPool.Ping(pool.PreferRO) - require.Nilf(t, err, "failed to Ping") - require.Nilf(t, data, "response data is not nil after Ping") + data, err = connPool.Do(tarantool.NewPingRequest(), pool.PreferRO).Get() + require.Nilf(t, err, "failed to Do with Ping Request") + require.Nilf(t, data, "response data is not nil after Do with Ping Request") } func TestDo(t *testing.T) { diff --git a/pool/connector.go b/pool/connector.go index 391b83b75..c984bfd32 100644 --- a/pool/connector.go +++ b/pool/connector.go @@ -56,326 +56,6 @@ func (c *ConnectorAdapter) ConfiguredTimeout() time.Duration { return ret } -// Ping sends empty request to Tarantool to check connection. -// -// Deprecated: the method will be removed in the next major version, -// use a PingRequest object + Do() instead. -func (c *ConnectorAdapter) Ping() ([]interface{}, error) { - return c.pool.Ping(c.mode) -} - -// Select performs select to box space. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (c *ConnectorAdapter) Select(space, index interface{}, - offset, limit uint32, iterator tarantool.Iter, - key interface{}) ([]interface{}, error) { - return c.pool.Select(space, index, offset, limit, iterator, key, c.mode) -} - -// Insert performs insertion to box space. -// -// Deprecated: the method will be removed in the next major version, -// use an InsertRequest object + Do() instead. -func (c *ConnectorAdapter) Insert(space interface{}, - tuple interface{}) ([]interface{}, error) { - return c.pool.Insert(space, tuple, c.mode) -} - -// Replace performs "insert or replace" action to box space. -// -// Deprecated: the method will be removed in the next major version, -// use a ReplaceRequest object + Do() instead. -func (c *ConnectorAdapter) Replace(space interface{}, - tuple interface{}) ([]interface{}, error) { - return c.pool.Replace(space, tuple, c.mode) -} - -// Delete performs deletion of a tuple by key. -// -// Deprecated: the method will be removed in the next major version, -// use a DeleteRequest object + Do() instead. -func (c *ConnectorAdapter) Delete(space, index interface{}, - key interface{}) ([]interface{}, error) { - return c.pool.Delete(space, index, key, c.mode) -} - -// Update performs update of a tuple by key. -// -// Deprecated: the method will be removed in the next major version, -// use a UpdateRequest object + Do() instead. -func (c *ConnectorAdapter) Update(space, index interface{}, - key interface{}, ops *tarantool.Operations) ([]interface{}, error) { - return c.pool.Update(space, index, key, ops, c.mode) -} - -// Upsert performs "update or insert" action of a tuple by key. -// -// Deprecated: the method will be removed in the next major version, -// use a UpsertRequest object + Do() instead. -func (c *ConnectorAdapter) Upsert(space, tuple interface{}, - ops *tarantool.Operations) ([]interface{}, error) { - return c.pool.Upsert(space, tuple, ops, c.mode) -} - -// Call calls registered Tarantool function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a CallRequest object + Do() instead. -func (c *ConnectorAdapter) Call(functionName string, - args interface{}) ([]interface{}, error) { - return c.pool.Call(functionName, args, c.mode) -} - -// Call16 calls registered Tarantool function. -// It uses request code for Tarantool 1.6, result is an array of arrays. -// Deprecated since Tarantool 1.7.2. -// -// Deprecated: the method will be removed in the next major version, -// use a Call16Request object + Do() instead. -func (c *ConnectorAdapter) Call16(functionName string, - args interface{}) ([]interface{}, error) { - return c.pool.Call16(functionName, args, c.mode) -} - -// Call17 calls registered Tarantool function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a Call17Request object + Do() instead. -func (c *ConnectorAdapter) Call17(functionName string, - args interface{}) ([]interface{}, error) { - return c.pool.Call17(functionName, args, c.mode) -} - -// Eval passes Lua expression for evaluation. -// -// Deprecated: the method will be removed in the next major version, -// use an EvalRequest object + Do() instead. -func (c *ConnectorAdapter) Eval(expr string, - args interface{}) ([]interface{}, error) { - return c.pool.Eval(expr, args, c.mode) -} - -// Execute passes sql expression to Tarantool for execution. -// -// Deprecated: the method will be removed in the next major version, -// use an ExecuteRequest object + Do() instead. -func (c *ConnectorAdapter) Execute(expr string, - args interface{}) ([]interface{}, error) { - return c.pool.Execute(expr, args, c.mode) -} - -// GetTyped performs select (with limit = 1 and offset = 0) -// to box space and fills typed result. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (c *ConnectorAdapter) GetTyped(space, index interface{}, - key interface{}, result interface{}) error { - return c.pool.GetTyped(space, index, key, result, c.mode) -} - -// SelectTyped performs select to box space and fills typed result. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (c *ConnectorAdapter) SelectTyped(space, index interface{}, - offset, limit uint32, iterator tarantool.Iter, - key interface{}, result interface{}) error { - return c.pool.SelectTyped(space, index, offset, limit, iterator, key, result, c.mode) -} - -// InsertTyped performs insertion to box space. -// -// Deprecated: the method will be removed in the next major version, -// use an InsertRequest object + Do() instead. -func (c *ConnectorAdapter) InsertTyped(space interface{}, - tuple interface{}, result interface{}) error { - return c.pool.InsertTyped(space, tuple, result, c.mode) -} - -// ReplaceTyped performs "insert or replace" action to box space. -// -// Deprecated: the method will be removed in the next major version, -// use a ReplaceRequest object + Do() instead. -func (c *ConnectorAdapter) ReplaceTyped(space interface{}, - tuple interface{}, result interface{}) error { - return c.pool.ReplaceTyped(space, tuple, result, c.mode) -} - -// DeleteTyped performs deletion of a tuple by key and fills result with deleted tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a DeleteRequest object + Do() instead. -func (c *ConnectorAdapter) DeleteTyped(space, index interface{}, - key interface{}, result interface{}) error { - return c.pool.DeleteTyped(space, index, key, result, c.mode) -} - -// UpdateTyped performs update of a tuple by key and fills result with updated tuple. -// -// Deprecated: the method will be removed in the next major version, -// use a UpdateRequest object + Do() instead. -func (c *ConnectorAdapter) UpdateTyped(space, index interface{}, - key interface{}, ops *tarantool.Operations, result interface{}) error { - return c.pool.UpdateTyped(space, index, key, ops, result, c.mode) -} - -// CallTyped calls registered function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a CallRequest object + Do() instead. -func (c *ConnectorAdapter) CallTyped(functionName string, - args interface{}, result interface{}) error { - return c.pool.CallTyped(functionName, args, result, c.mode) -} - -// Call16Typed calls registered function. -// It uses request code for Tarantool 1.6, result is an array of arrays. -// Deprecated since Tarantool 1.7.2. -// -// Deprecated: the method will be removed in the next major version, -// use a Call16Request object + Do() instead. -func (c *ConnectorAdapter) Call16Typed(functionName string, - args interface{}, result interface{}) error { - return c.pool.Call16Typed(functionName, args, result, c.mode) -} - -// Call17Typed calls registered function. -// It uses request code for Tarantool >= 1.7, result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a Call17Request object + Do() instead. -func (c *ConnectorAdapter) Call17Typed(functionName string, - args interface{}, result interface{}) error { - return c.pool.Call17Typed(functionName, args, result, c.mode) -} - -// EvalTyped passes Lua expression for evaluation. -// -// Deprecated: the method will be removed in the next major version, -// use an EvalRequest object + Do() instead. -func (c *ConnectorAdapter) EvalTyped(expr string, args interface{}, - result interface{}) error { - return c.pool.EvalTyped(expr, args, result, c.mode) -} - -// ExecuteTyped passes sql expression to Tarantool for execution. -// -// Deprecated: the method will be removed in the next major version, -// use an ExecuteRequest object + Do() instead. -func (c *ConnectorAdapter) ExecuteTyped(expr string, args interface{}, - result interface{}) (tarantool.SQLInfo, []tarantool.ColumnMetaData, error) { - return c.pool.ExecuteTyped(expr, args, result, c.mode) -} - -// SelectAsync sends select request to Tarantool and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use a SelectRequest object + Do() instead. -func (c *ConnectorAdapter) SelectAsync(space, index interface{}, - offset, limit uint32, iterator tarantool.Iter, key interface{}) *tarantool.Future { - return c.pool.SelectAsync(space, index, offset, limit, iterator, key, c.mode) -} - -// InsertAsync sends insert action to Tarantool and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use an InsertRequest object + Do() instead. -func (c *ConnectorAdapter) InsertAsync(space interface{}, - tuple interface{}) *tarantool.Future { - return c.pool.InsertAsync(space, tuple, c.mode) -} - -// ReplaceAsync sends "insert or replace" action to Tarantool and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use a ReplaceRequest object + Do() instead. -func (c *ConnectorAdapter) ReplaceAsync(space interface{}, - tuple interface{}) *tarantool.Future { - return c.pool.ReplaceAsync(space, tuple, c.mode) -} - -// DeleteAsync sends deletion action to Tarantool and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use a DeleteRequest object + Do() instead. -func (c *ConnectorAdapter) DeleteAsync(space, index interface{}, - key interface{}) *tarantool.Future { - return c.pool.DeleteAsync(space, index, key, c.mode) -} - -// Update sends deletion of a tuple by key and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use a UpdateRequest object + Do() instead. -func (c *ConnectorAdapter) UpdateAsync(space, index interface{}, - key interface{}, ops *tarantool.Operations) *tarantool.Future { - return c.pool.UpdateAsync(space, index, key, ops, c.mode) -} - -// UpsertAsync sends "update or insert" action to Tarantool and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use a UpsertRequest object + Do() instead. -func (c *ConnectorAdapter) UpsertAsync(space, tuple interface{}, - ops *tarantool.Operations) *tarantool.Future { - return c.pool.UpsertAsync(space, tuple, ops, c.mode) -} - -// CallAsync sends a call to registered Tarantool function and returns Future. -// It uses request code for Tarantool >= 1.7, future's result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a CallRequest object + Do() instead. -func (c *ConnectorAdapter) CallAsync(functionName string, - args interface{}) *tarantool.Future { - return c.pool.CallAsync(functionName, args, c.mode) -} - -// Call16Async sends a call to registered Tarantool function and returns Future. -// It uses request code for Tarantool 1.6, so future's result is an array of arrays. -// Deprecated since Tarantool 1.7.2. -// -// Deprecated: the method will be removed in the next major version, -// use a Call16Request object + Do() instead. -func (c *ConnectorAdapter) Call16Async(functionName string, - args interface{}) *tarantool.Future { - return c.pool.Call16Async(functionName, args, c.mode) -} - -// Call17Async sends a call to registered Tarantool function and returns Future. -// It uses request code for Tarantool >= 1.7, future's result is an array. -// -// Deprecated: the method will be removed in the next major version, -// use a Call17Request object + Do() instead. -func (c *ConnectorAdapter) Call17Async(functionName string, - args interface{}) *tarantool.Future { - return c.pool.Call17Async(functionName, args, c.mode) -} - -// EvalAsync sends a Lua expression for evaluation and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use an EvalRequest object + Do() instead. -func (c *ConnectorAdapter) EvalAsync(expr string, - args interface{}) *tarantool.Future { - return c.pool.EvalAsync(expr, args, c.mode) -} - -// ExecuteAsync sends a sql expression for execution and returns Future. -// -// Deprecated: the method will be removed in the next major version, -// use an EvalRequest object + Do() instead. -func (c *ConnectorAdapter) ExecuteAsync(expr string, - args interface{}) *tarantool.Future { - return c.pool.ExecuteAsync(expr, args, c.mode) -} - // NewPrepared passes a sql statement to Tarantool for preparation // synchronously. func (c *ConnectorAdapter) NewPrepared(expr string) (*tarantool.Prepared, error) { diff --git a/pool/connector_test.go b/pool/connector_test.go index 9b8106c12..3ed8ea81d 100644 --- a/pool/connector_test.go +++ b/pool/connector_test.go @@ -124,966 +124,10 @@ func TestConnectorConfiguredTimeoutWithError(t *testing.T) { // Tests for that ConnectorAdapter is just a proxy for requests. -type baseRequestMock struct { - Pooler - called int - functionName string - offset, limit uint32 - iterator tarantool.Iter - space, index interface{} - args, tuple, key, ops interface{} - result interface{} - mode Mode -} - -var reqData []interface{} var errReq error = errors.New("response error") var reqFuture *tarantool.Future = &tarantool.Future{} var reqFunctionName string = "any_name" -var reqOffset uint32 = 1 -var reqLimit uint32 = 2 -var reqIterator tarantool.Iter = tarantool.IterLt -var reqSpace interface{} = []interface{}{1} -var reqIndex interface{} = []interface{}{2} -var reqArgs interface{} = []interface{}{3} -var reqTuple interface{} = []interface{}{4} -var reqKey interface{} = []interface{}{5} -var reqOps = tarantool.NewOperations() - -var reqResult interface{} = []interface{}{7} -var reqSqlInfo = tarantool.SQLInfo{AffectedCount: 3} -var reqMeta = []tarantool.ColumnMetaData{{FieldIsNullable: false}} - -type getTypedMock struct { - baseRequestMock -} - -func (m *getTypedMock) GetTyped(space, index, key interface{}, - result interface{}, mode ...Mode) error { - m.called++ - m.space = space - m.index = index - m.key = key - m.result = result - m.mode = mode[0] - return errReq -} - -func TestConnectorGetTyped(t *testing.T) { - m := &getTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.GetTyped(reqSpace, reqIndex, reqKey, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type selectMock struct { - baseRequestMock -} - -func (m *selectMock) Select(space, index interface{}, - offset, limit uint32, iterator tarantool.Iter, key interface{}, - mode ...Mode) ([]interface{}, error) { - m.called++ - m.space = space - m.index = index - m.offset = offset - m.limit = limit - m.iterator = iterator - m.key = key - m.mode = mode[0] - return reqData, errReq -} - -func TestConnectorSelect(t *testing.T) { - m := &selectMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Select(reqSpace, reqIndex, reqOffset, reqLimit, reqIterator, reqKey) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqOffset, m.offset, "unexpected offset was passed") - require.Equalf(t, reqLimit, m.limit, "unexpected limit was passed") - require.Equalf(t, reqIterator, m.iterator, "unexpected iterator was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type selectTypedMock struct { - baseRequestMock -} - -func (m *selectTypedMock) SelectTyped(space, index interface{}, - offset, limit uint32, iterator tarantool.Iter, key interface{}, - result interface{}, mode ...Mode) error { - m.called++ - m.space = space - m.index = index - m.offset = offset - m.limit = limit - m.iterator = iterator - m.key = key - m.result = result - m.mode = mode[0] - return errReq -} - -func TestConnectorSelectTyped(t *testing.T) { - m := &selectTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.SelectTyped(reqSpace, reqIndex, reqOffset, reqLimit, - reqIterator, reqKey, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqOffset, m.offset, "unexpected offset was passed") - require.Equalf(t, reqLimit, m.limit, "unexpected limit was passed") - require.Equalf(t, reqIterator, m.iterator, "unexpected iterator was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type selectAsyncMock struct { - baseRequestMock -} - -func (m *selectAsyncMock) SelectAsync(space, index interface{}, - offset, limit uint32, iterator tarantool.Iter, key interface{}, - mode ...Mode) *tarantool.Future { - m.called++ - m.space = space - m.index = index - m.offset = offset - m.limit = limit - m.iterator = iterator - m.key = key - m.mode = mode[0] - return reqFuture -} - -func TestConnectorSelectAsync(t *testing.T) { - m := &selectAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.SelectAsync(reqSpace, reqIndex, reqOffset, reqLimit, - reqIterator, reqKey) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqOffset, m.offset, "unexpected offset was passed") - require.Equalf(t, reqLimit, m.limit, "unexpected limit was passed") - require.Equalf(t, reqIterator, m.iterator, "unexpected iterator was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type insertMock struct { - baseRequestMock -} - -func (m *insertMock) Insert(space, tuple interface{}, - mode ...Mode) ([]interface{}, error) { - m.called++ - m.space = space - m.tuple = tuple - m.mode = mode[0] - return reqData, errReq -} - -func TestConnectorInsert(t *testing.T) { - m := &insertMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Insert(reqSpace, reqTuple) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type insertTypedMock struct { - baseRequestMock -} - -func (m *insertTypedMock) InsertTyped(space, tuple interface{}, - result interface{}, mode ...Mode) error { - m.called++ - m.space = space - m.tuple = tuple - m.result = result - m.mode = mode[0] - return errReq -} - -func TestConnectorInsertTyped(t *testing.T) { - m := &insertTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.InsertTyped(reqSpace, reqTuple, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type insertAsyncMock struct { - baseRequestMock -} - -func (m *insertAsyncMock) InsertAsync(space, tuple interface{}, - mode ...Mode) *tarantool.Future { - m.called++ - m.space = space - m.tuple = tuple - m.mode = mode[0] - return reqFuture -} - -func TestConnectorInsertAsync(t *testing.T) { - m := &insertAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.InsertAsync(reqSpace, reqTuple) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type replaceMock struct { - baseRequestMock -} - -func (m *replaceMock) Replace(space, tuple interface{}, - mode ...Mode) ([]interface{}, error) { - m.called++ - m.space = space - m.tuple = tuple - m.mode = mode[0] - return reqData, errReq -} - -func TestConnectorReplace(t *testing.T) { - m := &replaceMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Replace(reqSpace, reqTuple) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type replaceTypedMock struct { - baseRequestMock -} - -func (m *replaceTypedMock) ReplaceTyped(space, tuple interface{}, - result interface{}, mode ...Mode) error { - m.called++ - m.space = space - m.tuple = tuple - m.result = result - m.mode = mode[0] - return errReq -} - -func TestConnectorReplaceTyped(t *testing.T) { - m := &replaceTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.ReplaceTyped(reqSpace, reqTuple, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type replaceAsyncMock struct { - baseRequestMock -} - -func (m *replaceAsyncMock) ReplaceAsync(space, tuple interface{}, - mode ...Mode) *tarantool.Future { - m.called++ - m.space = space - m.tuple = tuple - m.mode = mode[0] - return reqFuture -} - -func TestConnectorReplaceAsync(t *testing.T) { - m := &replaceAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.ReplaceAsync(reqSpace, reqTuple) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type deleteMock struct { - baseRequestMock -} - -func (m *deleteMock) Delete(space, index, key interface{}, - mode ...Mode) ([]interface{}, error) { - m.called++ - m.space = space - m.index = index - m.key = key - m.mode = mode[0] - return reqData, errReq -} - -func TestConnectorDelete(t *testing.T) { - m := &deleteMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Delete(reqSpace, reqIndex, reqKey) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type deleteTypedMock struct { - baseRequestMock -} - -func (m *deleteTypedMock) DeleteTyped(space, index, key interface{}, - result interface{}, mode ...Mode) error { - m.called++ - m.space = space - m.index = index - m.key = key - m.result = result - m.mode = mode[0] - return errReq -} - -func TestConnectorDeleteTyped(t *testing.T) { - m := &deleteTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.DeleteTyped(reqSpace, reqIndex, reqKey, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type deleteAsyncMock struct { - baseRequestMock -} - -func (m *deleteAsyncMock) DeleteAsync(space, index, key interface{}, - mode ...Mode) *tarantool.Future { - m.called++ - m.space = space - m.index = index - m.key = key - m.mode = mode[0] - return reqFuture -} - -func TestConnectorDeleteAsync(t *testing.T) { - m := &deleteAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.DeleteAsync(reqSpace, reqIndex, reqKey) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type updateMock struct { - baseRequestMock -} - -func (m *updateMock) Update(space, index, key interface{}, - ops *tarantool.Operations, mode ...Mode) ([]interface{}, error) { - m.called++ - m.space = space - m.index = index - m.key = key - m.ops = ops - m.mode = mode[0] - return reqData, errReq -} - -func TestConnectorUpdate(t *testing.T) { - m := &updateMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Update(reqSpace, reqIndex, reqKey, reqOps) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, reqOps, m.ops, "unexpected ops was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type updateTypedMock struct { - baseRequestMock -} - -func (m *updateTypedMock) UpdateTyped(space, index, key interface{}, - ops *tarantool.Operations, result interface{}, mode ...Mode) error { - m.called++ - m.space = space - m.index = index - m.key = key - m.ops = ops - m.result = result - m.mode = mode[0] - return errReq -} - -func TestConnectorUpdateTyped(t *testing.T) { - m := &updateTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.UpdateTyped(reqSpace, reqIndex, reqKey, reqOps, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, reqOps, m.ops, "unexpected ops was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type updateAsyncMock struct { - baseRequestMock -} - -func (m *updateAsyncMock) UpdateAsync(space, index, key interface{}, - ops *tarantool.Operations, mode ...Mode) *tarantool.Future { - m.called++ - m.space = space - m.index = index - m.key = key - m.ops = ops - m.mode = mode[0] - return reqFuture -} - -func TestConnectorUpdateAsync(t *testing.T) { - m := &updateAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.UpdateAsync(reqSpace, reqIndex, reqKey, reqOps) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqIndex, m.index, "unexpected index was passed") - require.Equalf(t, reqKey, m.key, "unexpected key was passed") - require.Equalf(t, reqOps, m.ops, "unexpected ops was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type upsertMock struct { - baseRequestMock -} - -func (m *upsertMock) Upsert(space, tuple interface{}, ops *tarantool.Operations, - mode ...Mode) ([]interface{}, error) { - m.called++ - m.space = space - m.tuple = tuple - m.ops = ops - m.mode = mode[0] - return reqData, errReq -} - -func TestConnectorUpsert(t *testing.T) { - m := &upsertMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Upsert(reqSpace, reqTuple, reqOps) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, reqOps, m.ops, "unexpected ops was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type upsertAsyncMock struct { - baseRequestMock -} - -func (m *upsertAsyncMock) UpsertAsync(space, tuple interface{}, - ops *tarantool.Operations, mode ...Mode) *tarantool.Future { - m.called++ - m.space = space - m.tuple = tuple - m.ops = ops - m.mode = mode[0] - return reqFuture -} - -func TestConnectorUpsertAsync(t *testing.T) { - m := &upsertAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.UpsertAsync(reqSpace, reqTuple, reqOps) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqSpace, m.space, "unexpected space was passed") - require.Equalf(t, reqTuple, m.tuple, "unexpected tuple was passed") - require.Equalf(t, reqOps, m.ops, "unexpected ops was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type baseCallMock struct { - baseRequestMock -} - -func (m *baseCallMock) call(functionName string, args interface{}, - mode Mode) ([]interface{}, error) { - m.called++ - m.functionName = functionName - m.args = args - m.mode = mode - return reqData, errReq -} - -func (m *baseCallMock) callTyped(functionName string, args interface{}, - result interface{}, mode Mode) error { - m.called++ - m.functionName = functionName - m.args = args - m.result = result - m.mode = mode - return errReq -} - -func (m *baseCallMock) callAsync(functionName string, args interface{}, - mode Mode) *tarantool.Future { - m.called++ - m.functionName = functionName - m.args = args - m.mode = mode - return reqFuture -} - -type callMock struct { - baseCallMock -} - -func (m *callMock) Call(functionName string, args interface{}, - mode Mode) ([]interface{}, error) { - return m.call(functionName, args, mode) -} - -func TestConnectorCall(t *testing.T) { - m := &callMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Call(reqFunctionName, reqArgs) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type callTypedMock struct { - baseCallMock -} - -func (m *callTypedMock) CallTyped(functionName string, args interface{}, - result interface{}, mode Mode) error { - return m.callTyped(functionName, args, result, mode) -} - -func TestConnectorCallTyped(t *testing.T) { - m := &callTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.CallTyped(reqFunctionName, reqArgs, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type callAsyncMock struct { - baseCallMock -} - -func (m *callAsyncMock) CallAsync(functionName string, args interface{}, - mode Mode) *tarantool.Future { - return m.callAsync(functionName, args, mode) -} - -func TestConnectorCallAsync(t *testing.T) { - m := &callAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.CallAsync(reqFunctionName, reqArgs) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type call16Mock struct { - baseCallMock -} - -func (m *call16Mock) Call16(functionName string, args interface{}, - mode Mode) ([]interface{}, error) { - return m.call(functionName, args, mode) -} - -func TestConnectorCall16(t *testing.T) { - m := &call16Mock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Call16(reqFunctionName, reqArgs) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type call16TypedMock struct { - baseCallMock -} - -func (m *call16TypedMock) Call16Typed(functionName string, args interface{}, - result interface{}, mode Mode) error { - return m.callTyped(functionName, args, result, mode) -} - -func TestConnectorCall16Typed(t *testing.T) { - m := &call16TypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.Call16Typed(reqFunctionName, reqArgs, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type call16AsyncMock struct { - baseCallMock -} - -func (m *call16AsyncMock) Call16Async(functionName string, args interface{}, - mode Mode) *tarantool.Future { - return m.callAsync(functionName, args, mode) -} - -func TestConnectorCall16Async(t *testing.T) { - m := &call16AsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.Call16Async(reqFunctionName, reqArgs) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type call17Mock struct { - baseCallMock -} - -func (m *call17Mock) Call17(functionName string, args interface{}, - mode Mode) ([]interface{}, error) { - return m.call(functionName, args, mode) -} - -func TestConnectorCall17(t *testing.T) { - m := &call17Mock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Call17(reqFunctionName, reqArgs) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type call17TypedMock struct { - baseCallMock -} - -func (m *call17TypedMock) Call17Typed(functionName string, args interface{}, - result interface{}, mode Mode) error { - return m.callTyped(functionName, args, result, mode) -} - -func TestConnectorCall17Typed(t *testing.T) { - m := &call17TypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.Call17Typed(reqFunctionName, reqArgs, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type call17AsyncMock struct { - baseCallMock -} - -func (m *call17AsyncMock) Call17Async(functionName string, args interface{}, - mode Mode) *tarantool.Future { - return m.callAsync(functionName, args, mode) -} - -func TestConnectorCall17Async(t *testing.T) { - m := &call17AsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.Call17Async(reqFunctionName, reqArgs) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected functionName was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type evalMock struct { - baseCallMock -} - -func (m *evalMock) Eval(functionName string, args interface{}, - mode Mode) ([]interface{}, error) { - return m.call(functionName, args, mode) -} - -func TestConnectorEval(t *testing.T) { - m := &evalMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Eval(reqFunctionName, reqArgs) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected expr was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type evalTypedMock struct { - baseCallMock -} - -func (m *evalTypedMock) EvalTyped(functionName string, args interface{}, - result interface{}, mode Mode) error { - return m.callTyped(functionName, args, result, mode) -} - -func TestConnectorEvalTyped(t *testing.T) { - m := &evalTypedMock{} - c := NewConnectorAdapter(m, testMode) - - err := c.EvalTyped(reqFunctionName, reqArgs, reqResult) - - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected expr was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type evalAsyncMock struct { - baseCallMock -} - -func (m *evalAsyncMock) EvalAsync(functionName string, args interface{}, - mode Mode) *tarantool.Future { - return m.callAsync(functionName, args, mode) -} - -func TestConnectorEvalAsync(t *testing.T) { - m := &evalAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.EvalAsync(reqFunctionName, reqArgs) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected expr was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type executeMock struct { - baseCallMock -} - -func (m *executeMock) Execute(functionName string, args interface{}, - mode Mode) ([]interface{}, error) { - return m.call(functionName, args, mode) -} - -func TestConnectorExecute(t *testing.T) { - m := &executeMock{} - c := NewConnectorAdapter(m, testMode) - - resp, err := c.Execute(reqFunctionName, reqArgs) - - require.Equalf(t, reqData, resp, "unexpected response") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected expr was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type executeTypedMock struct { - baseCallMock -} - -func (m *executeTypedMock) ExecuteTyped(functionName string, args, result interface{}, - mode Mode) (tarantool.SQLInfo, []tarantool.ColumnMetaData, error) { - m.callTyped(functionName, args, result, mode) - return reqSqlInfo, reqMeta, errReq -} - -func TestConnectorExecuteTyped(t *testing.T) { - m := &executeTypedMock{} - c := NewConnectorAdapter(m, testMode) - - info, meta, err := c.ExecuteTyped(reqFunctionName, reqArgs, reqResult) - - require.Equalf(t, reqSqlInfo, info, "unexpected info") - require.Equalf(t, reqMeta, meta, "unexpected meta") - require.Equalf(t, errReq, err, "unexpected error") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected expr was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, reqResult, m.result, "unexpected result was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - -type executeAsyncMock struct { - baseCallMock -} - -func (m *executeAsyncMock) ExecuteAsync(functionName string, args interface{}, - mode Mode) *tarantool.Future { - return m.callAsync(functionName, args, mode) -} - -func TestConnectorExecuteAsync(t *testing.T) { - m := &executeAsyncMock{} - c := NewConnectorAdapter(m, testMode) - - fut := c.ExecuteAsync(reqFunctionName, reqArgs) - - require.Equalf(t, reqFuture, fut, "unexpected future") - require.Equalf(t, 1, m.called, "should be called only once") - require.Equalf(t, reqFunctionName, m.functionName, - "unexpected expr was passed") - require.Equalf(t, reqArgs, m.args, "unexpected args was passed") - require.Equalf(t, testMode, m.mode, "unexpected proxy mode") -} - var reqPrepared *tarantool.Prepared = &tarantool.Prepared{} type newPreparedMock struct { diff --git a/pool/pooler.go b/pool/pooler.go index fd3df3401..1d05d1eb9 100644 --- a/pool/pooler.go +++ b/pool/pooler.go @@ -29,142 +29,4 @@ type Pooler interface { NewWatcher(key string, callback tarantool.WatchCallback, mode Mode) (tarantool.Watcher, error) Do(req tarantool.Request, mode Mode) (fut *tarantool.Future) - - // Deprecated: the method will be removed in the next major version, - // use a PingRequest object + Do() instead. - Ping(mode Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - Select(space, index interface{}, offset, limit uint32, iterator tarantool.Iter, - key interface{}, mode ...Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use an InsertRequest object + Do() instead. - Insert(space interface{}, tuple interface{}, - mode ...Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a ReplaceRequest object + Do() instead. - Replace(space interface{}, tuple interface{}, - mode ...Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a DeleteRequest object + Do() instead. - Delete(space, index interface{}, key interface{}, - mode ...Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a UpdateRequest object + Do() instead. - Update(space, index interface{}, key interface{}, ops *tarantool.Operations, - mode ...Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a UpsertRequest object + Do() instead. - Upsert(space interface{}, tuple interface{}, ops *tarantool.Operations, - mode ...Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a CallRequest object + Do() instead. - Call(functionName string, args interface{}, - mode Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a Call16Request object + Do() instead. - Call16(functionName string, args interface{}, - mode Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use a Call17Request object + Do() instead. - Call17(functionName string, args interface{}, - mode Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use an EvalRequest object + Do() instead. - Eval(expr string, args interface{}, - mode Mode) ([]interface{}, error) - // Deprecated: the method will be removed in the next major version, - // use an ExecuteRequest object + Do() instead. - Execute(expr string, args interface{}, - mode Mode) ([]interface{}, error) - - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - GetTyped(space, index interface{}, key interface{}, result interface{}, - mode ...Mode) error - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - SelectTyped(space, index interface{}, offset, limit uint32, iterator tarantool.Iter, - key interface{}, result interface{}, mode ...Mode) error - // Deprecated: the method will be removed in the next major version, - // use an InsertRequest object + Do() instead. - InsertTyped(space interface{}, tuple interface{}, result interface{}, - mode ...Mode) error - // Deprecated: the method will be removed in the next major version, - // use a ReplaceRequest object + Do() instead. - ReplaceTyped(space interface{}, tuple interface{}, result interface{}, - mode ...Mode) error - // Deprecated: the method will be removed in the next major version, - // use a DeleteRequest object + Do() instead. - DeleteTyped(space, index interface{}, key interface{}, result interface{}, - mode ...Mode) error - // Deprecated: the method will be removed in the next major version, - // use a UpdateRequest object + Do() instead. - UpdateTyped(space, index interface{}, key interface{}, - ops *tarantool.Operations, result interface{}, mode ...Mode) error - // Deprecated: the method will be removed in the next major version, - // use a CallRequest object + Do() instead. - CallTyped(functionName string, args interface{}, result interface{}, - mode Mode) error - // Deprecated: the method will be removed in the next major version, - // use a Call16Request object + Do() instead. - Call16Typed(functionName string, args interface{}, result interface{}, - mode Mode) error - // Deprecated: the method will be removed in the next major version, - // use a Call17Request object + Do() instead. - Call17Typed(functionName string, args interface{}, result interface{}, - mode Mode) error - // Deprecated: the method will be removed in the next major version, - // use an EvalRequest object + Do() instead. - EvalTyped(expr string, args interface{}, result interface{}, - mode Mode) error - // Deprecated: the method will be removed in the next major version, - // use an ExecuteRequest object + Do() instead. - ExecuteTyped(expr string, args interface{}, result interface{}, - mode Mode) (tarantool.SQLInfo, []tarantool.ColumnMetaData, error) - - // Deprecated: the method will be removed in the next major version, - // use a SelectRequest object + Do() instead. - SelectAsync(space, index interface{}, offset, limit uint32, iterator tarantool.Iter, - key interface{}, mode ...Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use an InsertRequest object + Do() instead. - InsertAsync(space interface{}, tuple interface{}, - mode ...Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use a ReplaceRequest object + Do() instead. - ReplaceAsync(space interface{}, tuple interface{}, - mode ...Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use a DeleteRequest object + Do() instead. - DeleteAsync(space, index interface{}, key interface{}, - mode ...Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use a UpdateRequest object + Do() instead. - UpdateAsync(space, index interface{}, key interface{}, - ops *tarantool.Operations, mode ...Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use a UpsertRequest object + Do() instead. - UpsertAsync(space interface{}, tuple interface{}, ops *tarantool.Operations, - mode ...Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use a CallRequest object + Do() instead. - CallAsync(functionName string, args interface{}, - mode Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use a Call16Request object + Do() instead. - Call16Async(functionName string, args interface{}, - mode Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use a Call17Request object + Do() instead. - Call17Async(functionName string, args interface{}, - mode Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use an EvalRequest object + Do() instead. - EvalAsync(expr string, args interface{}, - mode Mode) *tarantool.Future - // Deprecated: the method will be removed in the next major version, - // use an ExecuteRequest object + Do() instead. - ExecuteAsync(expr string, args interface{}, - mode Mode) *tarantool.Future }