diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc index c563199aa8..27c1e7673e 100644 --- a/CHANGELOG.asciidoc +++ b/CHANGELOG.asciidoc @@ -23,10 +23,10 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima [[release-3-8-1]] === TinkerPop 3.8.1 (NOT OFFICIALLY RELEASED YET) -* Fixed bug in pre-repeat() `emit()/until()` where `emit()` and `until()` traversers weren't added to the results. - This release also includes changes from <>. +* Fixed bug in pre-repeat() `emit()/until()` where `emit()` and `until()` traversers weren't added to the results. +* Expose serialization functions for alternative transport protocols in gremlin-go * Improved Gremlint formatting to keep the first argument for a step on the same line if line breaks were required to meet max line length. * Improved Gremlint formatting to do greedy argument packing when possible so that more arguments can appear on a single line. diff --git a/gremlin-go/driver/client.go b/gremlin-go/driver/client.go index c484914f9d..705330192f 100644 --- a/gremlin-go/driver/client.go +++ b/gremlin-go/driver/client.go @@ -149,7 +149,7 @@ func (client *Client) Close() { // SubmitWithOptions submits a Gremlin script to the server with specified RequestOptions and returns a ResultSet. func (client *Client) SubmitWithOptions(traversalString string, requestOptions RequestOptions) (ResultSet, error) { client.logHandler.logf(Debug, submitStartedString, traversalString) - request := makeStringRequest(traversalString, client.traversalSource, client.session, requestOptions) + request := MakeStringRequest(traversalString, client.traversalSource, client.session, requestOptions) result, err := client.connections.write(&request) if err != nil { client.logHandler.logf(Error, logErrorGeneric, "Client.Submit()", err.Error()) @@ -171,7 +171,7 @@ func (client *Client) Submit(traversalString string, bindings ...map[string]inte // submitBytecode submits Bytecode to the server to execute and returns a ResultSet. func (client *Client) submitBytecode(bytecode *Bytecode) (ResultSet, error) { client.logHandler.logf(Debug, submitStartedBytecode, *bytecode) - request := makeBytecodeRequest(bytecode, client.traversalSource, client.session) + request := MakeBytecodeRequest(bytecode, client.traversalSource, client.session) return client.connections.write(&request) } diff --git a/gremlin-go/driver/connection_test.go b/gremlin-go/driver/connection_test.go index 153084dbb7..fa9cc0381e 100644 --- a/gremlin-go/driver/connection_test.go +++ b/gremlin-go/driver/connection_test.go @@ -382,7 +382,7 @@ func TestConnection(t *testing.T) { assert.NotNil(t, connection) assert.Equal(t, established, connection.state) defer deferredCleanup(t, connection) - request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) + request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) resultSet, err := connection.write(&request) assert.Nil(t, err) assert.NotNil(t, resultSet) @@ -400,7 +400,7 @@ func TestConnection(t *testing.T) { assert.NotNil(t, connection) assert.Equal(t, established, connection.state) defer deferredCleanup(t, connection) - request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) + request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) resultSet, err := connection.write(&request) assert.Nil(t, err) assert.NotNil(t, resultSet) @@ -436,7 +436,7 @@ func TestConnection(t *testing.T) { err = connection.close() assert.Nil(t, err) assert.Equal(t, closed, connection.state) - request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) + request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) resultSet, err := connection.write(&request) assert.Nil(t, resultSet) assert.Equal(t, newError(err0102WriteConnectionClosedError), err) @@ -452,7 +452,7 @@ func TestConnection(t *testing.T) { assert.Equal(t, established, connection.state) assert.Nil(t, err) time.Sleep(120 * time.Second) - request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) + request := MakeStringRequest("g.V().count()", "g", "", *new(RequestOptions)) resultSet, err := connection.write(&request) assert.Nil(t, resultSet) assert.NotNil(t, err) diff --git a/gremlin-go/driver/protocol.go b/gremlin-go/driver/protocol.go index da44bb7807..1a5a8e3df1 100644 --- a/gremlin-go/driver/protocol.go +++ b/gremlin-go/driver/protocol.go @@ -44,7 +44,7 @@ type protocolBase struct { type gremlinServerWSProtocol struct { *protocolBase - serializer serializer + serializer Serializer logHandler *logHandler closed bool mutex sync.Mutex @@ -72,7 +72,7 @@ func (protocol *gremlinServerWSProtocol) readLoop(resultSets *synchronizedMap, e } // Deserialize message and unpack. - resp, err := protocol.serializer.deserializeMessage(msg) + resp, err := protocol.serializer.DeserializeMessage(msg) if err != nil { protocol.logHandler.logf(Error, logErrorGeneric, "gremlinServerWSProtocol.readLoop()", err.Error()) readErrorHandler(resultSets, errorCallback, err, protocol.logHandler) @@ -94,9 +94,9 @@ func readErrorHandler(resultSets *synchronizedMap, errorCallback func(), err err errorCallback() } -func (protocol *gremlinServerWSProtocol) responseHandler(resultSets *synchronizedMap, response response) error { - responseID, statusCode, metadata, data := response.responseID, response.responseStatus.code, - response.responseResult.meta, response.responseResult.data +func (protocol *gremlinServerWSProtocol) responseHandler(resultSets *synchronizedMap, response Response) error { + responseID, statusCode, metadata, data := response.ResponseID, response.ResponseStatus.code, + response.ResponseResult.Meta, response.ResponseResult.Data responseIDString := responseID.String() if resultSets.load(responseIDString) == nil { return newError(err0501ResponseHandlerResultSetNotCreatedError) @@ -113,7 +113,7 @@ func (protocol *gremlinServerWSProtocol) responseHandler(resultSets *synchronize } else if statusCode == http.StatusOK { // Add data and status attributes to the ResultSet. resultSets.load(responseIDString).addResult(&Result{data}) - resultSets.load(responseIDString).setStatusAttributes(response.responseStatus.attributes) + resultSets.load(responseIDString).setStatusAttributes(response.ResponseStatus.attributes) resultSets.load(responseIDString).Close() protocol.logHandler.logf(Debug, readComplete, responseIDString) } else if statusCode == http.StatusPartialContent { @@ -137,10 +137,10 @@ func (protocol *gremlinServerWSProtocol) responseHandler(resultSets *synchronize } } else { resultSets.load(responseIDString).Close() - return newError(err0503ResponseHandlerAuthError, response.responseStatus, response.responseResult) + return newError(err0503ResponseHandlerAuthError, response.ResponseStatus, response.ResponseResult) } } else { - newError := newError(err0502ResponseHandlerReadLoopError, response.responseStatus, statusCode) + newError := newError(err0502ResponseHandlerReadLoopError, response.ResponseStatus, statusCode) resultSets.load(responseIDString).setError(newError) resultSets.load(responseIDString).Close() protocol.logHandler.logf(Error, logErrorGeneric, "gremlinServerWSProtocol.responseHandler()", newError.Error()) @@ -149,7 +149,7 @@ func (protocol *gremlinServerWSProtocol) responseHandler(resultSets *synchronize } func (protocol *gremlinServerWSProtocol) write(request *request) error { - bytes, err := protocol.serializer.serializeMessage(request) + bytes, err := protocol.serializer.SerializeMessage(request) if err != nil { return err } diff --git a/gremlin-go/driver/request.go b/gremlin-go/driver/request.go index 31a57ef8cd..436a8a39fd 100644 --- a/gremlin-go/driver/request.go +++ b/gremlin-go/driver/request.go @@ -36,7 +36,28 @@ const sessionProcessor = "session" const stringOp = "eval" const stringProcessor = "" -func makeStringRequest(stringGremlin string, traversalSource string, sessionId string, requestOptions RequestOptions) (req request) { +// MakeStringRequest creates a request from a Gremlin string query for submission to a Gremlin server. +// +// This function is exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.) +// to construct properly formatted requests outside the standard WebSocket client. The returned +// request can then be serialized using SerializeMessage(). +// +// Parameters: +// - stringGremlin: The Gremlin query string to execute +// - traversalSource: The name of the traversal source (typically "g") +// - sessionId: Optional session ID for stateful requests (use "" for stateless) +// - requestOptions: Options such as bindings, timeout, batch size, etc. +// +// Returns: +// - request: A request structure ready for serialization +// +// Example for alternative transports: +// +// req := MakeStringRequest("g.V().count()", "g", "", RequestOptions{}) +// serializer := newGraphBinarySerializer(nil) +// bytes, _ := serializer.(graphBinarySerializer).SerializeMessage(&req) +// // Send bytes over gRPC, HTTP/2, etc. +func MakeStringRequest(stringGremlin string, traversalSource string, sessionId string, requestOptions RequestOptions) (req request) { newProcessor := stringProcessor newArgs := map[string]interface{}{ "gremlin": stringGremlin, @@ -88,7 +109,28 @@ const bytecodeProcessor = "traversal" const authOp = "authentication" const authProcessor = "traversal" -func makeBytecodeRequest(bytecodeGremlin *Bytecode, traversalSource string, sessionId string) (req request) { +// MakeBytecodeRequest creates a request from Gremlin bytecode for submission to a Gremlin server. +// +// This function is exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.) +// to construct properly formatted requests outside the standard WebSocket client. The returned +// request can then be serialized using SerializeMessage(). +// +// Parameters: +// - bytecodeGremlin: The Gremlin bytecode to execute +// - traversalSource: The name of the traversal source (typically "g") +// - sessionId: Optional session ID for stateful requests (use "" for stateless) +// +// Returns: +// - request: A request structure ready for serialization +// +// Example for alternative transports: +// +// bytecode := g.V().HasLabel("person").Bytecode +// req := MakeBytecodeRequest(bytecode, "g", "") +// serializer := newGraphBinarySerializer(nil) +// bytes, _ := serializer.(graphBinarySerializer).SerializeMessage(&req) +// // Send bytes over gRPC, HTTP/2, etc. +func MakeBytecodeRequest(bytecodeGremlin *Bytecode, traversalSource string, sessionId string) (req request) { newProcessor := bytecodeProcessor newArgs := map[string]interface{}{ "gremlin": *bytecodeGremlin, diff --git a/gremlin-go/driver/request_test.go b/gremlin-go/driver/request_test.go index c388a1273e..e20a5a06de 100644 --- a/gremlin-go/driver/request_test.go +++ b/gremlin-go/driver/request_test.go @@ -20,28 +20,29 @@ under the License. package gremlingo import ( - "github.com/google/uuid" "testing" + "github.com/google/uuid" + "github.com/stretchr/testify/assert" ) func TestRequest(t *testing.T) { t.Run("Test makeStringRequest() with custom requestID", func(t *testing.T) { requestId := uuid.New() - r := makeStringRequest("g.V()", "g", "", + r := MakeStringRequest("g.V()", "g", "", new(RequestOptionsBuilder).SetRequestId(requestId).Create()) assert.Equal(t, requestId, r.requestID) }) t.Run("Test makeStringRequest() with no bindings", func(t *testing.T) { - r := makeStringRequest("g.V()", "g", "", *new(RequestOptions)) + r := MakeStringRequest("g.V()", "g", "", *new(RequestOptions)) assert.NotNil(t, r.requestID) assert.NotEqual(t, uuid.Nil, r.requestID) }) t.Run("Test makeStringRequest() with custom evaluationTimeout", func(t *testing.T) { - r := makeStringRequest("g.V()", "g", "", + r := MakeStringRequest("g.V()", "g", "", new(RequestOptionsBuilder).SetEvaluationTimeout(1234).Create()) assert.NotNil(t, r.requestID) assert.NotEqual(t, uuid.Nil, r.requestID) @@ -49,7 +50,7 @@ func TestRequest(t *testing.T) { }) t.Run("Test makeStringRequest() with custom batchSize", func(t *testing.T) { - r := makeStringRequest("g.V()", "g", "", + r := MakeStringRequest("g.V()", "g", "", new(RequestOptionsBuilder).SetBatchSize(123).Create()) assert.NotNil(t, r.requestID) assert.NotEqual(t, uuid.Nil, r.requestID) @@ -57,7 +58,7 @@ func TestRequest(t *testing.T) { }) t.Run("Test makeStringRequest() with custom userAgent", func(t *testing.T) { - r := makeStringRequest("g.V()", "g", "", + r := MakeStringRequest("g.V()", "g", "", new(RequestOptionsBuilder).SetUserAgent("TestUserAgent").Create()) assert.NotNil(t, r.requestID) assert.NotEqual(t, uuid.Nil, r.requestID) diff --git a/gremlin-go/driver/response.go b/gremlin-go/driver/response.go index 67430116ba..6eadf351b5 100644 --- a/gremlin-go/driver/response.go +++ b/gremlin-go/driver/response.go @@ -21,22 +21,22 @@ package gremlingo import "github.com/google/uuid" -// responseStatus contains the status info of the response. -type responseStatus struct { +// ResponseStatus contains the status info of the response. +type ResponseStatus struct { code uint16 message string attributes map[string]interface{} } -// responseResult contains the result info of the response. -type responseResult struct { - meta map[string]interface{} - data interface{} +// ResponseResult contains the result info of the response. +type ResponseResult struct { + Meta map[string]interface{} + Data interface{} } -// response represents a response from the server. -type response struct { - responseID uuid.UUID - responseStatus responseStatus - responseResult responseResult +// Response represents a Response from the server. +type Response struct { + ResponseID uuid.UUID + ResponseStatus ResponseStatus + ResponseResult ResponseResult } diff --git a/gremlin-go/driver/resultSet.go b/gremlin-go/driver/resultSet.go index 73269deddd..6472880b77 100644 --- a/gremlin-go/driver/resultSet.go +++ b/gremlin-go/driver/resultSet.go @@ -211,3 +211,49 @@ func newChannelResultSetCapacity(requestID string, container *synchronizedMap, c func newChannelResultSet(requestID string, container *synchronizedMap) ResultSet { return newChannelResultSetCapacity(requestID, container, defaultCapacity) } + +// NewResultSet creates a new ResultSet from a slice of Result objects. +// This function enables custom transport implementations to create ResultSets from +// results collected via alternative protocols. +// +// The function creates a channel-based ResultSet, pre-populates it with the provided results, +// and closes the channel to indicate completion. +// +// Parameters: +// - requestID: The request identifier for this ResultSet +// - results: A slice of Result objects to include in the ResultSet +// +// Returns: +// - ResultSet: A ResultSet containing all the provided results +// +// Example usage: +// +// var results []*Result +// // Collect results from custom transport +// for _, responseBytes := range responses { +// result, _ := DeserializeResult(responseBytes) +// results = append(results, result) +// } +// resultSet := NewResultSet("request-123", results) +// allResults, _ := resultSet.All() +func NewResultSet(requestID string, results []*Result) ResultSet { + // Create a channel-based result set with capacity for all results + channelSize := len(results) + if channelSize == 0 { + channelSize = 1 // Ensure at least size 1 + } + rs := newChannelResultSetCapacity(requestID, &synchronizedMap{make(map[string]ResultSet), sync.Mutex{}}, channelSize).(*channelResultSet) + + // Add all results to the channel + for _, result := range results { + rs.channel <- result + } + + // Close the channel to indicate no more results + rs.channelMutex.Lock() + rs.closed = true + close(rs.channel) + rs.channelMutex.Unlock() + + return rs +} diff --git a/gremlin-go/driver/serializer.go b/gremlin-go/driver/serializer.go index 52034c7a0d..28f1c0ff07 100644 --- a/gremlin-go/driver/serializer.go +++ b/gremlin-go/driver/serializer.go @@ -32,14 +32,14 @@ import ( const graphBinaryMimeType = "application/vnd.graphbinary-v1.0" -// serializer interface for serializers. -type serializer interface { - serializeMessage(request *request) ([]byte, error) - deserializeMessage(message []byte) (response, error) +// Serializer interface for serializers. +type Serializer interface { + SerializeMessage(request *request) ([]byte, error) + DeserializeMessage(message []byte) (Response, error) } -// graphBinarySerializer serializes/deserializes message to/from GraphBinary. -type graphBinarySerializer struct { +// GraphBinarySerializer serializes/deserializes message to/from GraphBinary. +type GraphBinarySerializer struct { ser *graphBinaryTypeSerializer } @@ -61,14 +61,14 @@ func init() { initDeserializers() } -func newGraphBinarySerializer(handler *logHandler) serializer { +func newGraphBinarySerializer(handler *logHandler) Serializer { serializer := graphBinaryTypeSerializer{handler} - return graphBinarySerializer{&serializer} + return GraphBinarySerializer{&serializer} } const versionByte byte = 0x81 -func convertArgs(request *request, gs graphBinarySerializer) (map[string]interface{}, error) { +func convertArgs(request *request, gs GraphBinarySerializer) (map[string]interface{}, error) { if request.op != bytecodeProcessor { return request.args, nil } @@ -95,8 +95,28 @@ func convertArgs(request *request, gs graphBinarySerializer) (map[string]interfa } } -// serializeMessage serializes a request message into GraphBinary. -func (gs graphBinarySerializer) serializeMessage(request *request) ([]byte, error) { +// SerializeMessage serializes a request message into GraphBinary format. +// +// This method is part of the serializer interface and is used internally by the WebSocket driver. +// It is also exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.) to +// serialize requests created with MakeBytecodeRequest() or MakeStringRequest(). +// +// The serialized bytes can be transmitted over any transport protocol that supports binary data. +// +// Parameters: +// - request: The request to serialize (created via MakeBytecodeRequest or MakeStringRequest) +// +// Returns: +// - []byte: The GraphBinary-encoded request ready for transmission +// - error: Any serialization error encountered +// +// Example for alternative transports: +// +// req := MakeBytecodeRequest(bytecode, "g", "") +// serializer := newGraphBinarySerializer(nil) +// bytes, err := serializer.(graphBinarySerializer).SerializeMessage(&req) +// // Send bytes over custom transport +func (gs GraphBinarySerializer) SerializeMessage(request *request) ([]byte, error) { args, err := convertArgs(request, gs) if err != nil { return nil, err @@ -108,7 +128,7 @@ func (gs graphBinarySerializer) serializeMessage(request *request) ([]byte, erro return finalMessage, nil } -func (gs *graphBinarySerializer) buildMessage(id uuid.UUID, mimeLen byte, op string, processor string, args map[string]interface{}) ([]byte, error) { +func (gs *GraphBinarySerializer) buildMessage(id uuid.UUID, mimeLen byte, op string, processor string, args map[string]interface{}) ([]byte, error) { buffer := bytes.Buffer{} // mime header @@ -184,9 +204,27 @@ func uuidToBigInt(requestID uuid.UUID) big.Int { return bigInt } -// deserializeMessage deserializes a response message. -func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, error) { - var msg response +// DeserializeMessage deserializes a GraphBinary-encoded response message. +// +// This method is part of the serializer interface and is used internally by the WebSocket driver. +// It is also exposed publicly to enable alternative transport protocols (gRPC, HTTP/2, etc.) to +// deserialize responses received from a Gremlin server. +// +// Parameters: +// - message: The GraphBinary-encoded response bytes +// +// Returns: +// - response: The deserialized response containing results and metadata +// - error: Any deserialization error encountered +// +// Example for alternative transports: +// +// // Receive bytes from custom transport +// serializer := newGraphBinarySerializer(nil) +// resp, err := serializer.(graphBinarySerializer).DeserializeMessage(responseBytes) +// results := resp.responseResult.data +func (gs GraphBinarySerializer) DeserializeMessage(message []byte) (Response, error) { + var msg Response if message == nil || len(message) == 0 { gs.ser.logHandler.log(Error, nullInput) @@ -199,27 +237,27 @@ func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, er if err != nil { return msg, err } - msg.responseID = id.(uuid.UUID) - msg.responseStatus.code = uint16(readUint32Safe(&message, &i) & 0xFF) + msg.ResponseID = id.(uuid.UUID) + msg.ResponseStatus.code = uint16(readUint32Safe(&message, &i) & 0xFF) isMessageValid := readByteSafe(&message, &i) if isMessageValid == 0 { message, err := readString(&message, &i) if err != nil { return msg, err } - msg.responseStatus.message = message.(string) + msg.ResponseStatus.message = message.(string) } attr, err := readMapUnqualified(&message, &i) if err != nil { return msg, err } - msg.responseStatus.attributes = attr.(map[string]interface{}) + msg.ResponseStatus.attributes = attr.(map[string]interface{}) meta, err := readMapUnqualified(&message, &i) if err != nil { return msg, err } - msg.responseResult.meta = meta.(map[string]interface{}) - msg.responseResult.data, err = readFullyQualifiedNullable(&message, &i, true) + msg.ResponseResult.Meta = meta.(map[string]interface{}) + msg.ResponseResult.Data, err = readFullyQualifiedNullable(&message, &i, true) if err != nil { return msg, err } diff --git a/gremlin-go/driver/serializer_test.go b/gremlin-go/driver/serializer_test.go index c2e1d2d4f0..b8689da16b 100644 --- a/gremlin-go/driver/serializer_test.go +++ b/gremlin-go/driver/serializer_test.go @@ -42,7 +42,7 @@ func TestSerializer(t *testing.T) { args: map[string]interface{}{"gremlin": "g.V().count()", "aliases": map[string]interface{}{"g": "g"}}, } serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English)) - serialized, _ := serializer.serializeMessage(&testRequest) + serialized, _ := serializer.SerializeMessage(&testRequest) stringified := fmt.Sprintf("%v", serialized) if stringified != mapDataOrder1 && stringified != mapDataOrder2 { assert.Fail(t, "Error, expected serialized map data to match one of the provided binary arrays. Can vary based on ordering of keyset, but must map to one of two.") @@ -52,14 +52,14 @@ func TestSerializer(t *testing.T) { t.Run("test serialized response message", func(t *testing.T) { responseByteArray := []byte{129, 0, 251, 37, 42, 74, 117, 221, 71, 191, 183, 78, 86, 53, 0, 12, 132, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 16, 47, 49, 50, 55, 46, 48, 46, 48, 46, 49, 58, 54, 50, 48, 51, 53, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0} serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English)) - response, err := serializer.deserializeMessage(responseByteArray) + response, err := serializer.DeserializeMessage(responseByteArray) assert.Nil(t, err) - assert.Equal(t, "fb252a4a-75dd-47bf-b74e-5635000c8464", response.responseID.String()) - assert.Equal(t, uint16(200), response.responseStatus.code) - assert.Equal(t, "", response.responseStatus.message) - assert.Equal(t, map[string]interface{}{"host": "/127.0.0.1:62035"}, response.responseStatus.attributes) - assert.Equal(t, map[string]interface{}{}, response.responseResult.meta) - assert.Equal(t, []interface{}{int64(0)}, response.responseResult.data) + assert.Equal(t, "fb252a4a-75dd-47bf-b74e-5635000c8464", response.ResponseID.String()) + assert.Equal(t, uint16(200), response.ResponseStatus.code) + assert.Equal(t, "", response.ResponseStatus.message) + assert.Equal(t, map[string]interface{}{"host": "/127.0.0.1:62035"}, response.ResponseStatus.attributes) + assert.Equal(t, map[string]interface{}{}, response.ResponseResult.Meta) + assert.Equal(t, []interface{}{int64(0)}, response.ResponseResult.Data) }) t.Run("test serialized response message w/ custom type", func(t *testing.T) { @@ -69,14 +69,14 @@ func TestSerializer(t *testing.T) { }() responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62, 75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48, 46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117, 115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 0, 0, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 16, 240, 0, 0, 0, 0, 0, 0, 100, 21, 0, 0, 0, 0, 0, 0, 24, 30, 0, 0, 0, 0, 0, 0, 0, 32, 56} serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English)) - response, err := serializer.deserializeMessage(responseByteArray) + response, err := serializer.DeserializeMessage(responseByteArray) assert.Nil(t, err) - assert.Equal(t, "45de2837-5f3e-4bf9-8685-9b852b97dd44", response.responseID.String()) - assert.Equal(t, uint16(200), response.responseStatus.code) - assert.Equal(t, "", response.responseStatus.message) - assert.Equal(t, map[string]interface{}{"host": "/10.244.0.33:51470"}, response.responseStatus.attributes) - assert.Equal(t, map[string]interface{}{}, response.responseResult.meta) - assert.NotNil(t, response.responseResult.data) + assert.Equal(t, "45de2837-5f3e-4bf9-8685-9b852b97dd44", response.ResponseID.String()) + assert.Equal(t, uint16(200), response.ResponseStatus.code) + assert.Equal(t, "", response.ResponseStatus.message) + assert.Equal(t, map[string]interface{}{"host": "/10.244.0.33:51470"}, response.ResponseStatus.attributes) + assert.Equal(t, map[string]interface{}{}, response.ResponseResult.Meta) + assert.NotNil(t, response.ResponseResult.Data) }) } @@ -91,7 +91,7 @@ func TestSerializerFailures(t *testing.T) { args: map[string]interface{}{"invalidInput": "invalidInput", "aliases": map[string]interface{}{"g": "g"}}, } serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English)) - resp, err := serializer.serializeMessage(&testRequest) + resp, err := serializer.SerializeMessage(&testRequest) assert.Nil(t, resp) assert.NotNil(t, err) assert.True(t, isSameErrorCode(newError(err0704ConvertArgsNoSerializerError), err)) @@ -100,7 +100,7 @@ func TestSerializerFailures(t *testing.T) { t.Run("test unkownCustomType failure", func(t *testing.T) { responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62, 75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48, 46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117, 115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 0, 0, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 16, 240, 0, 0, 0, 0, 0, 0, 100, 21, 0, 0, 0, 0, 0, 0, 24, 30, 0, 0, 0, 0, 0, 0, 0, 32, 56} serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English)) - resp, err := serializer.deserializeMessage(responseByteArray) + resp, err := serializer.DeserializeMessage(responseByteArray) // a partial message will still be returned assert.NotNil(t, resp) assert.NotNil(t, err)