diff --git a/.codeclimate.yml b/.codeclimate.yml index 8d87d97..98d5f95 100644 --- a/.codeclimate.yml +++ b/.codeclimate.yml @@ -1,3 +1,4 @@ exclude_paths: - "**/mock_*.go" - - "**/*_test.go" \ No newline at end of file + - "**/*_test.go" + - "assert/*" \ No newline at end of file diff --git a/assert/assertions.go b/assert/assertions.go new file mode 100644 index 0000000..2022074 --- /dev/null +++ b/assert/assertions.go @@ -0,0 +1,243 @@ +package assert + +import ( + "bufio" + "bytes" + "fmt" + "reflect" + "runtime" + "strings" + "testing" + "unicode" + "unicode/utf8" +) + +func IsType(t *testing.T, expectedType interface{}, object interface{}) bool { + if !objectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) { + return fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object))) + } + + return true +} + +func Equal(t *testing.T, expected, actual interface{}) bool { + if objectsAreEqual(expected, actual) { + return true + } + return fail(t, fmt.Sprintf("Expected:\n%v\nBut Got:\n%v", expected, actual)) +} + +func Nil(t *testing.T, object interface{}) bool { + if isNil(object) { + return true + } + return fail(t, fmt.Sprintf("Expected nil, but got: %#v", object)) +} + +func True(t *testing.T, value bool) bool { + if !value { + return fail(t, "Should be true") + } + return true +} + +func False(t *testing.T, value bool) bool { + if value { + return fail(t, "Should be false") + } + return true +} + +func NoError(t *testing.T, err error) bool { + if err != nil { + return fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err)) + } + return true +} + +func EqualError(t *testing.T, theError error, errString string) bool { + if !isError(t, theError) { + return false + } + expected := errString + actual := theError.Error() + // don't need to use deep equals here, we know they are both strings + if expected != actual { + return fail(t, fmt.Sprintf("Error message not equal:\n"+ + "expected: %q\n"+ + "actual : %q", expected, actual)) + } + return true +} + +func ErrorContains(t *testing.T, theError error, contains string) bool { + if !isError(t, theError) { + return false + } + + actual := theError.Error() + if !strings.Contains(actual, contains) { + return fail(t, fmt.Sprintf("Error %#v does not contain %#v", actual, contains)) + } + + return true +} + +func objectsAreEqual(expected, actual interface{}) bool { + if expected == nil || actual == nil { + return expected == actual + } + + exp, ok := expected.([]byte) + if !ok { + return reflect.DeepEqual(expected, actual) + } + + act, ok := actual.([]byte) + if !ok { + return false + } + if exp == nil || act == nil { + return exp == nil && act == nil + } + return bytes.Equal(exp, act) +} + +func isError(t *testing.T, err error) bool { + if err == nil { + return fail(t, "An error is expected but got nil.") + } + return true +} + +func isNil(object interface{}) bool { + if object == nil { + return true + } + + value := reflect.ValueOf(object) + switch value.Kind() { + case + reflect.Chan, reflect.Func, + reflect.Interface, reflect.Map, + reflect.Ptr, reflect.Slice, reflect.UnsafePointer: + + return value.IsNil() + default: + return false + } +} + +func fail(t *testing.T, failureMessage string) bool { + content := []labeledContent{ + {"Error Trace", strings.Join(callerInfo(), "\n\t\t\t")}, + {"Error", failureMessage}, + } + t.Errorf("\n%s", ""+labeledOutput(content...)) + + return false +} + +func callerInfo() []string { + + var pc uintptr + var ok bool + var file string + var line int + var name string + + var callers []string + for i := 0; ; i++ { + pc, file, line, ok = runtime.Caller(i) + if !ok { + // The breaks below failed to terminate the loop, and we ran off the + // end of the call stack. + break + } + + // This is a huge edge case, but it will panic if this is the case, see #180 + if file == "" { + break + } + + f := runtime.FuncForPC(pc) + if f == nil { + break + } + name = f.Name() + + // testing.tRunner is the standard library function that calls + // tests. Subtests are called directly by tRunner, without going through + // the Test/Benchmark/Example function that contains the t.Run calls, so + // with subtests we should break when we hit tRunner, without adding it + // to the list of callers. + if name == "testing.tRunner" { + break + } + + parts := strings.Split(file, "/") + if len(parts) > 1 { + filename := parts[len(parts)-1] + dir := parts[len(parts)-2] + if (dir != "github.com/apimatic/go-core-runtime/assert" && dir != "mock" && dir != "require") || filename == "mock_test.go" { + callers = append(callers, fmt.Sprintf("%s:%d", file, line)) + } + } + + // Drop the package + segments := strings.Split(name, ".") + name = segments[len(segments)-1] + if isTest(name, "Test") || + isTest(name, "Benchmark") || + isTest(name, "Example") { + break + } + } + + return callers +} + +func isTest(name, prefix string) bool { + if !strings.HasPrefix(name, prefix) { + return false + } + if len(name) == len(prefix) { // "Test" is ok + return true + } + r, _ := utf8.DecodeRuneInString(name[len(prefix):]) + return !unicode.IsLower(r) +} + +type labeledContent struct { + label string + content string +} + +func labeledOutput(content ...labeledContent) string { + longestLabel := 0 + for _, v := range content { + if len(v.label) > longestLabel { + longestLabel = len(v.label) + } + } + var output string + for _, v := range content { + output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n" + } + return output +} + +func indentMessageLines(message string, longestLabelLen int) string { + outBuf := new(bytes.Buffer) + + for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ { + // no need to align first line because it starts at the correct location (after the label) + if i != 0 { + // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab + outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t") + } + outBuf.WriteString(scanner.Text()) + } + + return outBuf.String() +} diff --git a/go.mod b/go.mod index a1a71a8..3cb5a99 100644 --- a/go.mod +++ b/go.mod @@ -2,14 +2,12 @@ module github.com/apimatic/go-core-runtime go 1.18 +require github.com/go-openapi/jsonpointer v0.20.2 + require ( - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/go-openapi/jsonpointer v0.20.2 // indirect github.com/go-openapi/swag v0.22.5 // indirect github.com/josharian/intern v1.0.0 // indirect github.com/mailru/easyjson v0.7.7 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/stretchr/objx v0.5.0 // indirect - github.com/stretchr/testify v1.8.4 // indirect + github.com/rogpeppe/go-internal v1.12.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 021952f..445d17a 100644 --- a/go.sum +++ b/go.sum @@ -1,25 +1,19 @@ -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-openapi/jsonpointer v0.20.2 h1:mQc3nmndL8ZBzStEo3JYF8wzmeWffDH4VbXz58sAx6Q= github.com/go-openapi/jsonpointer v0.20.2/go.mod h1:bHen+N0u1KEO3YlmqOjTT9Adn1RfD91Ar825/PuiRVs= github.com/go-openapi/swag v0.22.5 h1:fVS63IE3M0lsuWRzuom3RLwUMVI2peDH01s6M70ugys= github.com/go-openapi/swag v0.22.5/go.mod h1:Gl91UqO+btAM0plGGxHqJcQZ1ZTy6jbmridBTsDy8A0= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/https/apiError_test.go b/https/apiError_test.go index 42dfb34..e55ca47 100644 --- a/https/apiError_test.go +++ b/https/apiError_test.go @@ -8,7 +8,7 @@ import ( "net/http" "testing" - "github.com/stretchr/testify/assert" + "github.com/apimatic/go-core-runtime/assert" ) const mockJSONResponseBody = `{ diff --git a/https/authenticationGroup_test.go b/https/authenticationGroup_test.go index 3a62760..b042407 100644 --- a/https/authenticationGroup_test.go +++ b/https/authenticationGroup_test.go @@ -6,7 +6,7 @@ import ( "strings" "testing" - "github.com/apimatic/go-core-runtime/utilities" + "github.com/apimatic/go-core-runtime/assert" ) const API_KEY = "api-key" @@ -99,12 +99,7 @@ func TestErrorWhenUndefinedAuth(t *testing.T) { _, err := request.Call() - utilities.AssertError(t, err) - - expected := AuthenticationError("authThatDoesntExist is undefined!") - actual := err.Error() - - utilities.AssertEquals(t, expected, actual) + assert.EqualError(t, err, AuthenticationError("authThatDoesntExist is undefined!")) } func TestSuccessfulCallWhenHeaderAuth(t *testing.T) { @@ -113,14 +108,14 @@ func TestSuccessfulCallWhenHeaderAuth(t *testing.T) { httpContext, err := request.Call() - utilities.AssertNoError(t, err) + assert.NoError(t, err) header := httpContext.Request.Header expected := MockHeaderToken actual := header.Get("api-key") - utilities.AssertEquals(t, expected, actual) + assert.Equal(t, expected, actual) } func TestSuccessfulCallWhenQueryAuth(t *testing.T) { @@ -129,14 +124,14 @@ func TestSuccessfulCallWhenQueryAuth(t *testing.T) { httpContext, err := request.Call() - utilities.AssertNoError(t, err) + assert.NoError(t, err) query := httpContext.Request.URL.Query() expected := MockQueryToken actual := query.Get("api-token") - utilities.AssertEquals(t, expected, actual) + assert.Equal(t, expected, actual) } func TestSuccessfulCallWhenHeaderAndQueryAuth(t *testing.T) { @@ -150,13 +145,13 @@ func TestSuccessfulCallWhenHeaderAndQueryAuth(t *testing.T) { httpContext, err := request.Call() - utilities.AssertNoError(t, err) + assert.NoError(t, err) headerToken := httpContext.Request.Header.Get(API_KEY) - utilities.AssertEquals(t, MockHeaderToken, headerToken) + assert.Equal(t, MockHeaderToken, headerToken) queryToken := httpContext.Request.URL.Query().Get(API_TOKEN) - utilities.AssertEquals(t, MockQueryToken, queryToken) + assert.Equal(t, MockQueryToken, queryToken) } func TestSuccessfulCallWhenHeaderOrQueryAuth(t *testing.T) { @@ -170,7 +165,7 @@ func TestSuccessfulCallWhenHeaderOrQueryAuth(t *testing.T) { httpContext, err := request.Call() - utilities.AssertNoError(t, err) + assert.NoError(t, err) headerToken := httpContext.Request.Header.Get(API_KEY) queryToken := httpContext.Request.URL.Query().Get(API_TOKEN) @@ -193,13 +188,13 @@ func TestSuccessfulCallWhenEmptyHeaderOrQueryAuth(t *testing.T) { httpContext, err := request.Call() - utilities.AssertNoError(t, err) + assert.NoError(t, err) headerToken := httpContext.Request.Header.Get(API_KEY) queryToken := httpContext.Request.URL.Query().Get(API_TOKEN) - utilities.AssertEquals(t, "", headerToken) - utilities.AssertEquals(t, MockQueryToken, queryToken) + assert.Equal(t, "", headerToken) + assert.Equal(t, MockQueryToken, queryToken) } func TestSuccessfulCallWhenHeaderOrMissingQueryAuth(t *testing.T) { @@ -213,14 +208,14 @@ func TestSuccessfulCallWhenHeaderOrMissingQueryAuth(t *testing.T) { httpContext, err := request.Call() - utilities.AssertNoError(t, err) + assert.NoError(t, err) headerToken := httpContext.Request.Header.Get(API_KEY) queryToken := httpContext.Request.URL.Query().Get(API_TOKEN) - utilities.AssertEquals(t, "", queryToken) + assert.Equal(t, "", queryToken) - utilities.AssertEquals(t, MockHeaderToken, headerToken) + assert.Equal(t, MockHeaderToken, headerToken) } func TestSuccessfulCallWhenMissingHeaderOrQueryAuth(t *testing.T) { @@ -234,13 +229,13 @@ func TestSuccessfulCallWhenMissingHeaderOrQueryAuth(t *testing.T) { httpContext, err := request.Call() - utilities.AssertNoError(t, err) + assert.NoError(t, err) headerToken := httpContext.Request.Header.Get(API_KEY) queryToken := httpContext.Request.URL.Query().Get(API_TOKEN) - utilities.AssertEquals(t, "", headerToken) - utilities.AssertEquals(t, MockQueryToken, queryToken) + assert.Equal(t, "", headerToken) + assert.Equal(t, MockQueryToken, queryToken) } func TestErrorWhenHeaderWithEmptyValueAndQueryAuth(t *testing.T) { @@ -254,12 +249,7 @@ func TestErrorWhenHeaderWithEmptyValueAndQueryAuth(t *testing.T) { _, err := request.Call() - utilities.AssertError(t, err) - - expected := AuthenticationError(API_KEY_MISSING_ERROR) - actual := err.Error() - - utilities.AssertEquals(t, expected, actual) + assert.EqualError(t, err, AuthenticationError(API_KEY_MISSING_ERROR)) } func TestErrorWhenHeaderAndQueryWithEmptyValueAuth(t *testing.T) { @@ -273,12 +263,7 @@ func TestErrorWhenHeaderAndQueryWithEmptyValueAuth(t *testing.T) { _, err := request.Call() - utilities.AssertError(t, err) - - expected := AuthenticationError(API_TOKEN_MISSING_ERROR) - actual := err.Error() - - utilities.AssertEquals(t, expected, actual) + assert.EqualError(t, err, AuthenticationError(API_TOKEN_MISSING_ERROR)) } func TestErrorWhenHeaderAndMissingQueryAuth(t *testing.T) { @@ -292,12 +277,7 @@ func TestErrorWhenHeaderAndMissingQueryAuth(t *testing.T) { _, err := request.Call() - utilities.AssertError(t, err) - - expected := AuthenticationError("missingQuery is undefined!") - actual := err.Error() - - utilities.AssertEquals(t, expected, actual) + assert.EqualError(t, err, AuthenticationError("missingQuery is undefined!")) } func TestErrorWhenMissingHeaderAndQueryAuth(t *testing.T) { @@ -311,12 +291,7 @@ func TestErrorWhenMissingHeaderAndQueryAuth(t *testing.T) { _, err := request.Call() - utilities.AssertError(t, err) - - expected := AuthenticationError("missingHeader is undefined!") - actual := err.Error() - - utilities.AssertEquals(t, expected, actual) + assert.EqualError(t, err, AuthenticationError("missingHeader is undefined!")) } func TestErrorWhenHeaderOrQueryAuthBothAreMissing(t *testing.T) { @@ -330,12 +305,7 @@ func TestErrorWhenHeaderOrQueryAuthBothAreMissing(t *testing.T) { _, err := request.Call() - utilities.AssertError(t, err) - - expected := AuthenticationError("headerMissing is undefined!", "queryMissing is undefined!") - actual := err.Error() - - utilities.AssertEquals(t, expected, actual) + assert.EqualError(t, err, AuthenticationError("headerMissing is undefined!", "queryMissing is undefined!")) } func TestErrorWhenHeaderOrQueryAuthBothAreEmpty(t *testing.T) { @@ -349,10 +319,5 @@ func TestErrorWhenHeaderOrQueryAuthBothAreEmpty(t *testing.T) { _, err := request.Call() - utilities.AssertError(t, err) - - expected := AuthenticationError(API_KEY_MISSING_ERROR, API_TOKEN_MISSING_ERROR) - actual := err.Error() - - utilities.AssertEquals(t, expected, actual) + assert.EqualError(t, err, AuthenticationError(API_KEY_MISSING_ERROR, API_TOKEN_MISSING_ERROR)) } diff --git a/https/callBuilder_test.go b/https/callBuilder_test.go index 08dc33b..d601094 100644 --- a/https/callBuilder_test.go +++ b/https/callBuilder_test.go @@ -9,7 +9,7 @@ import ( "strings" "testing" - "github.com/stretchr/testify/assert" + "github.com/apimatic/go-core-runtime/assert" ) var ctx = context.Background() diff --git a/utilities/apiHelper_test.go b/utilities/apiHelper_test.go index 88a6599..682e7ad 100644 --- a/utilities/apiHelper_test.go +++ b/utilities/apiHelper_test.go @@ -10,7 +10,7 @@ import ( "testing" "time" - "github.com/stretchr/testify/assert" + "github.com/apimatic/go-core-runtime/assert" ) // NullableTimeToStringMap diff --git a/utilities/assert.go b/utilities/assert.go deleted file mode 100644 index 9d75055..0000000 --- a/utilities/assert.go +++ /dev/null @@ -1,28 +0,0 @@ -package utilities - -import "testing" - -// Asserts that both values are equal. -// This may not apply to all types. -func AssertEquals[T comparable](t *testing.T, expected, actual T) { - if expected == actual { - return - } - t.Errorf("\n----------EXPECTED----------\n%v\n------------GOT------------\n%v", expected, actual) -} - -// Asserts that an error is returned (i.e. not nil). -func AssertError(t *testing.T, err error) { - if err != nil { - return - } - t.Errorf("Expected an error") -} - -// Asserts that no error is returned (i.e. nil). -func AssertNoError(t *testing.T, err error) { - if err == nil { - return - } - t.Fatalf("Unexpected Error: %s", err.Error()) -} diff --git a/utilities/internal_time_types_test.go b/utilities/internal_time_types_test.go index 7858b56..b6624ba 100644 --- a/utilities/internal_time_types_test.go +++ b/utilities/internal_time_types_test.go @@ -4,12 +4,14 @@ import ( "encoding/json" "testing" "time" + + "github.com/apimatic/go-core-runtime/assert" ) func TestUnixDateTimeString(t *testing.T) { newTime := time.Unix(1484719381, 0) unixDateTime := NewUnixDateTime(newTime) - AssertEquals(t, "1484719381", unixDateTime.String()) + assert.Equal(t, "1484719381", unixDateTime.String()) } func TestUnixDateTime(t *testing.T) { @@ -17,117 +19,117 @@ func TestUnixDateTime(t *testing.T) { unixDateTime := NewUnixDateTime(newTime) bytes, err := json.Marshal(unixDateTime) - AssertNoError(t, err) + assert.NoError(t, err) var newUnixDateTime UnixDateTime err = json.Unmarshal(bytes, &newUnixDateTime) - AssertNoError(t, err) - AssertEquals(t, newTime, newUnixDateTime.Value()) + assert.NoError(t, err) + assert.Equal(t, newTime, newUnixDateTime.Value()) } func TestUnixDateTimeError(t *testing.T) { var newUnixDateTime UnixDateTime err := json.Unmarshal([]byte(`"Sun, 06 Nov 1994 08:49:37 GMT"`), &newUnixDateTime) - AssertError(t, err) + assert.EqualError(t, err, "json: cannot unmarshal string into Go value of type int64") } func TestDefaultTimeString(t *testing.T) { newTime, err := time.Parse(DEFAULT_DATE, "1994-02-13") - AssertNoError(t, err) + assert.NoError(t, err) defaultTime := NewDefaultTime(newTime) - AssertEquals(t, "1994-02-13", defaultTime.String()) + assert.Equal(t, "1994-02-13", defaultTime.String()) } func TestDefaultTime(t *testing.T) { newTime, err := time.Parse(DEFAULT_DATE, "1994-02-13") - AssertNoError(t, err) + assert.NoError(t, err) defaultTime := NewDefaultTime(newTime) bytes, err := json.Marshal(defaultTime) - AssertNoError(t, err) + assert.NoError(t, err) var newDefaultTime DefaultTime err = json.Unmarshal(bytes, &newDefaultTime) - AssertNoError(t, err) - AssertEquals(t, newTime, newDefaultTime.Value()) + assert.NoError(t, err) + assert.Equal(t, newTime, newDefaultTime.Value()) } func TestDefaultTimeError1(t *testing.T) { var newDefaultTime DefaultTime err := json.Unmarshal([]byte(`1484719381`), &newDefaultTime) - AssertError(t, err) + assert.EqualError(t, err, "json: cannot unmarshal number into Go value of type string") } func TestDefaultTimeError2(t *testing.T) { var newDefaultTime DefaultTime err := json.Unmarshal([]byte(`"Sun, 06 Nov 1994 08:49:37 GMT"`), &newDefaultTime) - AssertError(t, err) + assert.EqualError(t, err, "parsing time \"Sun, 06 Nov 1994 08:49:37 GMT\" as \"2006-01-02\": cannot parse \"Sun, 06 Nov 1994 08:49:37 GMT\" as \"2006\"") } func TestRFC3339TimeString(t *testing.T) { newTime, err := time.Parse(time.RFC3339Nano, "1994-02-13T14:01:54.9571247Z") - AssertNoError(t, err) + assert.NoError(t, err) rFC3339Time := NewRFC3339Time(newTime) - AssertEquals(t, "1994-02-13T14:01:54.9571247Z", rFC3339Time.String()) + assert.Equal(t, "1994-02-13T14:01:54.9571247Z", rFC3339Time.String()) } func TestRFC3339Time(t *testing.T) { newTime, err := time.Parse(time.RFC3339Nano, "1994-02-13T14:01:54.9571247Z") - AssertNoError(t, err) + assert.NoError(t, err) rFC3339Time := NewRFC3339Time(newTime) bytes, err := json.Marshal(rFC3339Time) - AssertNoError(t, err) + assert.NoError(t, err) var newRFC3339Time RFC3339Time err = json.Unmarshal(bytes, &newRFC3339Time) - AssertNoError(t, err) - AssertEquals(t, newTime, newRFC3339Time.Value()) + assert.NoError(t, err) + assert.Equal(t, newTime, newRFC3339Time.Value()) } func TestRFC1123TimeString(t *testing.T) { newTime, err := time.Parse(time.RFC1123, "Sun, 06 Nov 1994 08:49:37 GMT") - AssertNoError(t, err) + assert.NoError(t, err) rFC1123Time := NewRFC1123Time(newTime) - AssertEquals(t, "Sun, 06 Nov 1994 08:49:37 GMT", rFC1123Time.String()) + assert.Equal(t, "Sun, 06 Nov 1994 08:49:37 GMT", rFC1123Time.String()) } func TestRFC1123Time(t *testing.T) { newTime, err := time.Parse(time.RFC1123, "Sun, 06 Nov 1994 08:49:37 GMT") - AssertNoError(t, err) + assert.NoError(t, err) rFC1123Time := NewRFC1123Time(newTime) bytes, err := json.Marshal(rFC1123Time) - AssertNoError(t, err) + assert.NoError(t, err) var newRFC1123Time RFC1123Time err = json.Unmarshal(bytes, &newRFC1123Time) - AssertNoError(t, err) - AssertEquals(t, newTime, rFC1123Time.Value()) + assert.NoError(t, err) + assert.Equal(t, newTime, rFC1123Time.Value()) } func TestObjSliceToTimeSlice(t *testing.T) { initialBytes := []byte(`["Sun, 06 Nov 1994 08:49:37 GMT","Sun, 06 Nov 1994 08:49:37 GMT"]`) var strArray []string err := json.Unmarshal(initialBytes, &strArray) - AssertNoError(t, err) + assert.NoError(t, err) timeArray, err := ToTimeSlice(strArray, time.RFC1123) - AssertNoError(t, err) + assert.NoError(t, err) newObjArray := TimeSliceToObjSlice[RFC1123Time](timeArray) newTimeArray := ObjSliceToTimeSlice(newObjArray) newStrArray := TimeToStringSlice(newTimeArray, time.RFC1123) resultBytes, err := json.Marshal(newStrArray) - AssertNoError(t, err) - AssertEquals(t, string(initialBytes), string(resultBytes)) + assert.NoError(t, err) + assert.Equal(t, string(initialBytes), string(resultBytes)) } func TestObjMapToTimeMap(t *testing.T) { initialBytes := []byte(`{"key1":"Sun, 06 Nov 1994 08:49:37 GMT","key2":"Sun, 06 Nov 1994 08:49:37 GMT"}`) var strMap map[string]string err := json.Unmarshal(initialBytes, &strMap) - AssertNoError(t, err) + assert.NoError(t, err) timeMap, err := ToTimeMap(strMap, time.RFC1123) - AssertNoError(t, err) + assert.NoError(t, err) newObjMap := TimeMapToObjMap[RFC1123Time](timeMap) newTimeMap := ObjMapToTimeMap(newObjMap) newStrMap := TimeToStringMap(newTimeMap, time.RFC1123) resultBytes, err := json.Marshal(newStrMap) - AssertNoError(t, err) - AssertEquals(t, string(initialBytes), string(resultBytes)) + assert.NoError(t, err) + assert.Equal(t, string(initialBytes), string(resultBytes)) } diff --git a/utilities/unionTypeHelper_test.go b/utilities/unionTypeHelper_test.go index 663f562..9e32719 100644 --- a/utilities/unionTypeHelper_test.go +++ b/utilities/unionTypeHelper_test.go @@ -4,7 +4,7 @@ import ( "encoding/json" "testing" - "github.com/stretchr/testify/assert" + "github.com/apimatic/go-core-runtime/assert" ) type UnionTypeCase struct {