changed cancelled to canceled

Author: Jeffrey D. King

cancelled.go canceled.gocancelled.go renamed to canceled.go

@@ -5,17 +5,17 @@ import (
 	status "google.golang.org/grpc/status"
 )
 
-// CancelledError indicates the operation was canceled (typically by the
+// CanceledError indicates the operation was canceled (typically by the
 // caller).
 //
 // Example error Message:
 //
-//		CANCELLED.
+//		CANCELED.
 //
 // HTTP Mapping: 499 CLIENT CLOSED REQUEST
 //
-// RPC Mapping: CANCELLED
-type CancelledError struct {
+// RPC Mapping: CANCELED
+type CanceledError struct {
 	Code       int    `json:"errorCode"`
 	Message    string `json:"errorMessage"`
 	logMessage string
@@ -24,15 +24,15 @@ type CancelledError struct {
 	rpcCode    codes.Code
 }
 
-// NewCancelledError returns a new CancelledError.
-func NewCancelledError(Message string, cause ...error) *CancelledError {
+// NewCanceledError returns a new CanceledError.
+func NewCanceledError(Message string, cause ...error) *CanceledError {
 	var c error
 	if len(cause) > 0 {
 		c = NewErrors(cause...)
 	}
-	return &CancelledError{
+	return &CanceledError{
 		Code:       499,
-		Message:    "CANCELLED. Request cancelled by the client.",
+		Message:    "CANCELED. Request canceled by the client.",
 		logMessage: Message,
 		cause:      c,
 		stack:      getTrace(),
@@ -41,27 +41,27 @@ func NewCancelledError(Message string, cause ...error) *CancelledError {
 }
 
 // Error implements the error interface
-func (e *CancelledError) Error() string { return errorStr(e) }
+func (e *CanceledError) Error() string { return errorStr(e) }
 
 // Timeout indicates if this error is the result of a timeout.
-func (e *CancelledError) Timeout() bool { return true }
+func (e *CanceledError) Timeout() bool { return true }
 
 // Temporary indicates if this error is potentially recoverable.
-func (e *CancelledError) Temporary() bool { return false }
+func (e *CanceledError) Temporary() bool { return false }
 
 // GetCode returns the HTTP status code associated with this error.
-func (e *CancelledError) GetCode() int { return e.Code }
+func (e *CanceledError) GetCode() int { return e.Code }
 
 // GetMessage returns the message associated with this error.
-func (e *CancelledError) GetMessage() string { return e.Message + " " + e.logMessage }
+func (e *CanceledError) GetMessage() string { return e.Message + " " + e.logMessage }
 
 // GetCause returns any causal errors associated with this error.
-func (e *CancelledError) GetCause() error { return e.cause }
+func (e *CanceledError) GetCause() error { return e.cause }
 
 // GetStack returns the trace stack associated with this error.
-func (e *CancelledError) GetStack() stack { return e.stack }
+func (e *CanceledError) GetStack() stack { return e.stack }
 
 // GRPCStatus implements an interface required to return proper GRPC status codes
-func (e *CancelledError) GRPCStatus() *status.Status {
+func (e *CanceledError) GRPCStatus() *status.Status {
 	return status.New(e.rpcCode, e.Message)
 }

canceled_test.go

@@ -0,0 +1,129 @@
+package errors
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	assert "github.com/stretchr/testify/assert"
+	codes "google.golang.org/grpc/codes"
+)
+
+type CanceledErrorTest struct {
+	err          *CanceledError
+	timeout      bool
+	temporary    bool
+	errorInfo    string
+	errorVerbose string
+	errorDebug   string
+	errorTrace   string
+	getCode      int
+	getMessage   string
+	getCause     error
+	json         []byte
+	rpcCode      codes.Code
+	rpcMessage   string
+}
+
+var CanceledErrorTests = []CanceledErrorTest{
+	{
+		err:        NewCanceledError("foo"),
+		timeout:    true,
+		temporary:  false,
+		errorInfo:  "error 499: CANCELED. Request canceled by the client. foo",
+		getCode:    499,
+		getMessage: "CANCELED. Request canceled by the client. foo",
+		getCause:   nil,
+		json:       []byte(`{"errorCode":499,"errorMessage":"CANCELED. Request canceled by the client."}`),
+		rpcCode:    codes.Canceled,
+		rpcMessage: "CANCELED. Request canceled by the client.",
+	},
+	{
+		err:        NewCanceledError("foo", errors.New("causal error")),
+		timeout:    true,
+		temporary:  false,
+		errorInfo:  "error 499: CANCELED. Request canceled by the client. foo",
+		getCode:    499,
+		getMessage: "CANCELED. Request canceled by the client. foo",
+		getCause:   errors.New("causal error"),
+		json:       []byte(`{"errorCode":499,"errorMessage":"CANCELED. Request canceled by the client."}`),
+		rpcCode:    codes.Canceled,
+		rpcMessage: "CANCELED. Request canceled by the client.",
+	},
+	{
+		err:        NewCanceledError("foo", errors.New("causal error"), errors.New("causal error 2")),
+		timeout:    true,
+		temporary:  false,
+		errorInfo:  "error 499: CANCELED. Request canceled by the client. foo",
+		getCode:    499,
+		getMessage: "CANCELED. Request canceled by the client. foo",
+		getCause:   NewErrors(errors.New("causal error"), errors.New("causal error 2")),
+		json:       []byte(`{"errorCode":499,"errorMessage":"CANCELED. Request canceled by the client."}`),
+		rpcCode:    codes.Canceled,
+		rpcMessage: "CANCELED. Request canceled by the client.",
+	},
+}
+
+func TestCanceledErrorTimeout(t *testing.T) {
+	for _, test := range CanceledErrorTests {
+		assert.Equal(t, test.timeout, test.err.Timeout())
+	}
+}
+
+func TestCanceledErrorTemporary(t *testing.T) {
+	for _, test := range CanceledErrorTests {
+		assert.Equal(t, test.temporary, test.err.Temporary())
+	}
+}
+
+func TestCanceledErrorError(t *testing.T) {
+	// note, all other verbosity states tested in error_test.go
+	SetVerbosity(Info)
+	for _, test := range CanceledErrorTests {
+		assert.Equal(t, test.errorInfo, test.err.Error())
+	}
+}
+
+func TestCanceledErrorGetCode(t *testing.T) {
+	for _, test := range CanceledErrorTests {
+		assert.Equal(t, test.getCode, test.err.GetCode())
+	}
+}
+
+func TestCanceledErrorGetMessage(t *testing.T) {
+	for _, test := range CanceledErrorTests {
+		assert.Equal(t, test.getMessage, test.err.GetMessage())
+	}
+}
+
+func TestCanceledErrorGetCause(t *testing.T) {
+	for _, test := range CanceledErrorTests {
+		if test.getCause == nil {
+			assert.Nil(t, test.err.GetCause())
+		} else {
+			assert.Equal(t, test.getCause.Error(), test.err.GetCause().Error())
+		}
+	}
+}
+
+func TestCanceledErrorGetStack(t *testing.T) {
+	// trace output prevents testing for string match in different contexts
+	for _, test := range CanceledErrorTests {
+		assert.NotNil(t, test.err.GetStack())
+	}
+}
+
+func TestCanceledErrorJson(t *testing.T) {
+	for _, test := range CanceledErrorTests {
+		json, _ := json.Marshal(test.err)
+		assert.Equal(t, string(json[:]), string((test.json)[:]))
+	}
+}
+
+func TestCanceledErrorGrpc(t *testing.T) {
+	for _, test := range CanceledErrorTests {
+		s := test.err.GRPCStatus()
+		assert.Equal(t, test.rpcCode, s.Code())
+		assert.Equal(t, test.rpcMessage, s.Message())
+	}
+}

cancelled_test.go

@@ -196,7 +196,7 @@ func TestErrorsTimeout(t *testing.T) {
 		timeout bool
 	}{
 		{
-			NewErrors(NewCancelledError("foo")),
+			NewErrors(NewCanceledError("foo")),
 			true,
 		},
 		{