docs update + tests

Author: DerekBum

CHANGELOG.md

@@ -28,6 +28,11 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
   in requests instead of their IDs.
 - `GetSchema` function to get the actual schema (#7)
 - Support connection via an existing socket fd (#321)
+- Ability to mock connections for tests (#237). Added new structs `MockDoer`, 
+  `MockRequest`.
+- `CreateResponse` method added to the `Request` interface (#237)
+- `Header` struct for the response header (#237). It can be accessed via 
+  `Header()` method of the `Response` interface.
 
 ### Changed
 
@@ -67,6 +72,22 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
   it (#321)
 - Rename `pool.GetPoolInfo` to `pool.GetInfo`. Change return type to
   `map[string]ConnectionInfo` (#321)
+- All responses are now implementations of an `Response` interface (#237).
+  `SelectResponse`, `ExecuteResponse`, `PrepareResponse`, `PushResponse` are part 
+  of a public API. `Pos()`, `MetaData()`, `SQLInfo()` methods created for them 
+  to get specific info.
+- `IsPush()` method is added to the response iterator (#237). It returns 
+  the information if the current response a `PushResponse`. 
+  `PushCode` constant is removed.
+- `Future` constructors now accept `Request` as their argument (#237). 
+  Method `Get` now returns response data. To get the actual response new method 
+  added `GetResponse`. Methods `AppendPush` and `SetResponse` accepts 
+  response `Header` and data as their arguments.
+- All deprecated requests operations on a `Connector` return response data 
+  instead of an actual responses (#237)
+- Renamed `StrangerResponse` to `MockResponse` (#237)
+- `GetSchema` now accepts a `Doer` as an argument (instead of the 
+  `Connection`) (#237)
 
 ### Deprecated
 

README.md

@@ -130,10 +130,10 @@ func main() {
 	}
 	resp, err := conn.Do(tarantool.NewInsertRequest(999).
 		Tuple([]interface{}{99999, "BB"}),
-	).Get()
+	).GetResponse()
 	if err != nil {
 		fmt.Println("Error", err)
-		fmt.Println("Code", resp.Code)
+		fmt.Println("Code", resp.Header().Code)
 	}
 }
 ```
@@ -201,12 +201,18 @@ The subpackage has been deleted. You could use `pool` instead.
   unique string ID, which allows them to be distinguished.
 * `pool.GetPoolInfo` has been renamed to `pool.GetInfo`. Return type has been changed
   to `map[string]ConnectionInfo`.
+* All deprecated requests operations on a `Pooler` return response data
+  instead of an actual responses.
 
 #### crud package
 
 * `crud` operations `Timeout` option has `crud.OptFloat64` type
   instead of `crud.OptUint`.
 
+#### test_helpers package
+
+Renamed `StrangerResponse` to `MockResponse`.
+
 #### msgpack.v5
 
 Most function names and argument types in `msgpack.v5` and `msgpack.v2`
@@ -241,7 +247,10 @@ of the requests is an array instead of array of arrays.
 
 #### IPROTO constants
 
-IPROTO constants have been moved to a separate package [go-iproto](https://github.com/tarantool/go-iproto).
+* IPROTO constants have been moved to a separate package [go-iproto](https://github.com/tarantool/go-iproto).
+* `PushCode` constant is removed. To get information, if the current response is 
+a push response, new `IsPush()` method of the response iterator could be used 
+instead.
 
 #### Request changes
 
@@ -254,6 +263,36 @@ longer accept `ops` argument (operations) as an `interface{}`. `*Operations`
 needs to be passed instead.
 * `UpdateRequest` and `UpsertRequest` structs no longer accept `interface{}`
 for an `ops` field. `*Operations` needs to be used instead.
+* `CreateResponse` method added to the `Request` interface.
+
+#### Response changes
+
+* New interface `Response` added.
+* For each request, a different response struct is created. They all implement a 
+`Response` interface. `SelectResponse`, `PrepareResponse`, `ExecuteResponse`, 
+`PushResponse` are a part of a public API. `Pos()`, `MetaData()`, `SQLInfo()` 
+methods created for them to get specific info.
+* Response header stored in a new `Header` struct. It could be accessed via 
+`Header()` method.
+
+#### Response iterator changes
+
+Method `IsPush()` is added to the `ResponseIterator` interface.
+It returns true if the current response is a push response.
+
+#### Future changes
+
+* `Future` constructors now accept `Request` as their argument.
+* Method `Get` now returns response data instead of the actual response.
+* New method `GetResponse` added to get an actual response.
+* Methods `AppendPush` and `SetResponse` accepts response `Header` and data 
+as their arguments.
+
+#### Connector changes
+
+* All deprecated requests operations on a `Connector` return response data
+instead of an actual responses.
+* New interface `Doer` is added as a child-interface instead of a `Do` method.
 
 #### Connect function
 
@@ -267,6 +306,10 @@ If you were using a non-SSL connection, you need to create `NetDialer`.
 For SSL-enabled connections, use `OpenSslDialer`. Please note that the options
 for creating a connection are now stored in corresponding `Dialer`, not in `Opts`.
 
+#### GetSchema function
+
+`GetSchema` now accepts a `Doer` as an argument.
+
 #### Connection schema
 
 * Removed `Schema` field from the `Connection` struct. Instead, new

example_test.go

@@ -198,16 +198,32 @@ func ExampleSelectRequest() {
 	}
 
 	key := []interface{}{uint(1111)}
-	data, err := conn.Do(tarantool.NewSelectRequest(617).
+	resp, err := conn.Do(tarantool.NewSelectRequest(617).
 		Limit(100).
 		Iterator(tarantool.IterEq).
 		Key(key),
-	).Get()
+	).GetResponse()
 
 	if err != nil {
 		fmt.Printf("error in select is %v", err)
 		return
 	}
+	selResp, ok := resp.(*tarantool.SelectResponse)
+	if !ok {
+		fmt.Print("wrong response type")
+		return
+	}
+	pos, err := selResp.Pos()
+	if err != nil {
+		fmt.Printf("error in Pos: %v", err)
+		return
+	}
+	fmt.Printf("pos for Select is %v\n", pos)
+	data, err := resp.Decode()
+	if err != nil {
+		fmt.Printf("error while decoding: %v", err)
+		return
+	}
 	fmt.Printf("response is %#v\n", data)
 
 	var res []Tuple
@@ -224,6 +240,7 @@ func ExampleSelectRequest() {
 	fmt.Printf("response is %v\n", res)
 
 	// Output:
+	// pos for Select is []
 	// response is []interface {}{[]interface {}{0x457, "hello", "world"}}
 	// response is [{{} 1111 hello world}]
 }
@@ -747,6 +764,46 @@ func ExampleExecuteRequest() {
 	fmt.Println("Error", err)
 }
 
+func ExamplePrepareRequest() {
+	conn := exampleConnect(dialer, opts)
+	defer conn.Close()
+
+	resp, err := conn.Do(
+		tarantool.NewPrepareRequest("SELECT NULL WHERE FALSE;"),
+	).GetResponse()
+
+	if err != nil {
+		fmt.Printf("error in prepare is %v", err)
+		return
+	}
+	prepResp, ok := resp.(*tarantool.PrepareResponse)
+	if !ok {
+		fmt.Print("wrong response type")
+		return
+	}
+	metaData, err := prepResp.MetaData()
+	if err != nil {
+		fmt.Printf("error in MetaData: %v", err)
+		return
+	}
+	fmt.Printf("metaData for Prepare is %v\n", metaData)
+	sqlInfo, err := prepResp.SQLInfo()
+	if err != nil {
+		fmt.Printf("error in SQLInfo: %v", err)
+		return
+	}
+	fmt.Printf("sqlInfo for Prepare is %v\n", sqlInfo)
+	_, err = resp.Decode()
+	if err != nil {
+		fmt.Printf("error while decoding: %v", err)
+		return
+	}
+
+	// Output:
+	// metaData for Prepare is [{COLUMN_1 scalar  false false }]
+	// sqlInfo for Prepare is {0 []}
+}
+
 func getTestTxnDialer() tarantool.Dialer {
 	txnDialer := dialer
 

future.go

@@ -158,11 +158,6 @@ func (fut *Future) AppendPush(header Header, body io.Reader) error {
 	return nil
 }
 
-// SetRequest sets a request, for which the future was created.
-func (fut *Future) SetRequest(req Request) {
-	fut.req = req
-}
-
 // SetResponse sets a response for the future and finishes the future.
 func (fut *Future) SetResponse(header Header, body io.Reader) error {
 	fut.mutex.Lock()

future_test.go

@@ -1,6 +1,7 @@
 package tarantool_test
 
 import (
+	"bytes"
 	"errors"
 	"sync"
 	"testing"
@@ -126,7 +127,6 @@ func TestFutureGetIteratorResponseOnTimeout(t *testing.T) {
 
 	wait.Wait()
 
-	fut.SetRequest(test_helpers.NewMockRequest())
 	fut.SetResponse(respHeader, nil)
 	done.Wait()
 }
@@ -259,3 +259,43 @@ func TestFutureSetStateRaceCondition(t *testing.T) {
 	// It may be false-positive, but very rarely - it's ok for such very
 	// simple race conditions tests.
 }
+
+func TestFutureGetIteratorIsPush(t *testing.T) {
+	fut := NewFuture(test_helpers.NewMockRequest())
+	fut.AppendPush(Header{}, nil)
+	fut.SetResponse(Header{}, nil)
+	it := fut.GetIterator()
+
+	assert.True(t, it.IsPush())
+	it.Next()
+	assert.False(t, it.IsPush())
+}
+
+func TestFuture_Get(t *testing.T) {
+	resp := test_helpers.NewMockResponse(t, []interface{}{'v', '2'})
+
+	fut := NewFuture(test_helpers.NewMockRequest())
+	fut.SetResponse(Header{}, bytes.NewBuffer(resp.GetData()))
+
+	data, err := fut.Get()
+	assert.NoError(t, err)
+	assert.Equal(t, 2, len(data))
+	assert.Equal(t, 'v', data[0])
+	assert.Equal(t, '2', data[1])
+}
+
+func TestFuture_GetResponse(t *testing.T) {
+	mockResp := test_helpers.NewMockResponse(t, []interface{}{'v', '2'})
+
+	fut := NewFuture(test_helpers.NewMockRequest())
+	fut.SetResponse(Header{}, bytes.NewBuffer(mockResp.GetData()))
+
+	resp, err := fut.GetResponse()
+	assert.NoError(t, err)
+
+	data, err := resp.Decode()
+	assert.NoError(t, err)
+	assert.Equal(t, 2, len(data))
+	assert.Equal(t, 'v', data[0])
+	assert.Equal(t, '2', data[1])
+}

request_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
@@ -1007,3 +1008,45 @@ func TestWatchOnceRequestDefaultValues(t *testing.T) {
 	req := NewWatchOnceRequest(validKey)
 	assertBodyEqual(t, refBuf.Bytes(), req)
 }
+
+func TestCreateResponse(t *testing.T) {
+	header := Header{}
+	data := bytes.NewBuffer([]byte{'v', '2'})
+	baseExample, err := NewPingRequest().CreateResponse(header, data)
+	assert.NoError(t, err)
+
+	tests := []struct {
+		req      Request
+		expected Response
+	}{
+		{req: NewSelectRequest(validSpace), expected: &SelectResponse{}},
+		{req: NewUpdateRequest(validSpace), expected: baseExample},
+		{req: NewUpsertRequest(validSpace), expected: baseExample},
+		{req: NewInsertRequest(validSpace), expected: baseExample},
+		{req: NewReplaceRequest(validSpace), expected: baseExample},
+		{req: NewDeleteRequest(validSpace), expected: baseExample},
+		{req: NewCallRequest(validExpr), expected: baseExample},
+		{req: NewCall16Request(validExpr), expected: baseExample},
+		{req: NewCall17Request(validExpr), expected: baseExample},
+		{req: NewEvalRequest(validExpr), expected: baseExample},
+		{req: NewExecuteRequest(validExpr), expected: &ExecuteResponse{}},
+		{req: NewPingRequest(), expected: baseExample},
+		{req: NewPrepareRequest(validExpr), expected: &PrepareResponse{}},
+		{req: NewUnprepareRequest(validStmt), expected: baseExample},
+		{req: NewExecutePreparedRequest(validStmt), expected: &ExecuteResponse{}},
+		{req: NewBeginRequest(), expected: baseExample},
+		{req: NewCommitRequest(), expected: baseExample},
+		{req: NewRollbackRequest(), expected: baseExample},
+		{req: NewIdRequest(validProtocolInfo), expected: baseExample},
+		{req: NewBroadcastRequest(validKey), expected: baseExample},
+		{req: NewWatchOnceRequest(validKey), expected: baseExample},
+	}
+
+	for _, test := range tests {
+		resp, err := test.req.CreateResponse(header, data)
+		assert.NoError(t, err)
+		assert.True(t, fmt.Sprintf("%T", resp) ==
+			fmt.Sprintf("%T", test.expected))
+		assert.Equal(t, header, resp.Header())
+	}
+}

test_helpers/response.go

@@ -19,6 +19,11 @@ type MockResponse struct {
 	data []byte
 }
 
+// GetData is a getter for a data field.
+func (resp *MockResponse) GetData() []byte {
+	return resp.data
+}
+
 // NewMockResponse creates a new MockResponse with an empty header and the given data.
 // body should be passed as a structure to be encoded.
 // The encoded body is served as response data and will be decoded once the