From 2eb62927337445429b01644f2711d88f4c751922 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mike=20Schw=C3=B6rer?= Date: Tue, 17 Jan 2023 20:41:45 +0100 Subject: [PATCH] improve AssertEqual to handle annoying `json.Unmarshal` type conversions... --- scnserver/test/compat_test.go | 20 +++--- scnserver/test/util/common.go | 111 ++++++++++++++++++++++++++++++++++ 2 files changed, 121 insertions(+), 10 deletions(-) diff --git a/scnserver/test/compat_test.go b/scnserver/test/compat_test.go index 551dd18..ba9f2a9 100644 --- a/scnserver/test/compat_test.go +++ b/scnserver/test/compat_test.go @@ -224,7 +224,7 @@ func TestSendCompatMessageByQuery(t *testing.T) { url.QueryEscape("message content"), url.QueryEscape("2"), url.QueryEscape("624dbe5e-6d03-47cd-9a0e-a306faa2e977"), - url.QueryEscape("1673894797")), nil) + url.QueryEscape(fmt.Sprintf("%d", time.Now().Unix()+666))), nil) tt.AssertEqual(t, "success", true, r2["success"]) tt.AssertEqual(t, "suppress_send", false, r2["suppress_send"]) @@ -241,7 +241,7 @@ func TestSendCompatMessageByQuery(t *testing.T) { url.QueryEscape("message content"), url.QueryEscape("2"), url.QueryEscape("624dbe5e-6d03-47cd-9a0e-a306faa2e977"), - url.QueryEscape("1673894797")), nil) + url.QueryEscape(fmt.Sprintf("%d", time.Now().Unix()+666))), nil) tt.AssertEqual(t, "success", true, r3["success"]) tt.AssertEqual(t, "suppress_send", true, r3["suppress_send"]) } @@ -278,7 +278,7 @@ func TestSendCompatMessageByFormData(t *testing.T) { "content": "message content", "priority": "2", "msg_id": "624dbe5e-6d03-47cd-9a0e-a306faa2e977", - "timestamp": "1673894797", + "timestamp": fmt.Sprintf("%d", time.Now().Unix()-666), }) tt.AssertEqual(t, "success", true, r2["success"]) tt.AssertEqual(t, "suppress_send", false, r2["suppress_send"]) @@ -296,7 +296,7 @@ func TestSendCompatMessageByFormData(t *testing.T) { "content": "message content", "priority": "2", "msg_id": "624dbe5e-6d03-47cd-9a0e-a306faa2e977", - "timestamp": "1673894797", + "timestamp": fmt.Sprintf("%d", time.Now().Unix()-666), }) tt.AssertEqual(t, "success", true, r3["success"]) tt.AssertEqual(t, "suppress_send", true, r3["suppress_send"]) @@ -324,13 +324,13 @@ func TestCompatInfo(t *testing.T) { tt.AssertEqual(t, "success", true, r1["success"]) tt.AssertEqual(t, "fcm_token_set", true, r1["fcm_token_set"]) - tt.AssertEqual(t, "is_pro", 0, int(r1["is_pro"].(float64))) + tt.AssertEqual(t, "is_pro", 0, r1["is_pro"]) tt.AssertEqual(t, "message", "ok", r1["message"]) - tt.AssertEqual(t, "quota", 0, int(r1["quota"].(float64))) - tt.AssertEqual(t, "quota_max", 50, int(r1["quota_max"].(float64))) - tt.AssertEqual(t, "unack_count", 0, int(r1["unack_count"].(float64))) - tt.AssertEqual(t, "user_id", userid, int64(r1["user_id"].(float64))) - tt.AssertEqual(t, "user_key", userkey, r1["user_key"].(string)) + tt.AssertEqual(t, "quota", 0, r1["quota"]) + tt.AssertEqual(t, "quota_max", 50, r1["quota_max"]) + tt.AssertEqual(t, "unack_count", 0, r1["unack_count"]) + tt.AssertEqual(t, "user_id", userid, r1["user_id"]) + tt.AssertEqual(t, "user_key", userkey, r1["user_key"]) } func TestCompatAck(t *testing.T) { diff --git a/scnserver/test/util/common.go b/scnserver/test/util/common.go index 348377b..cbb0a46 100644 --- a/scnserver/test/util/common.go +++ b/scnserver/test/util/common.go @@ -4,6 +4,7 @@ import ( "fmt" "github.com/gin-gonic/gin" "gogs.mikescher.com/BlackForestBytes/goext/langext" + "math" "reflect" "runtime/debug" "strings" @@ -34,6 +35,111 @@ func AssertJsonMapEqual(t *testing.T, key string, expected map[string]any, actua } func AssertEqual(t *testing.T, key string, expected any, actual any) { + + // try to fix types, kinda hacky, but its only unit tests... + switch vex := expected.(type) { + case int: + switch vac := actual.(type) { + case int: + // same + case int32: + expected = int64(vex) + actual = int64(vac) + case int64: + expected = int64(vex) + case float32: + if IsWholeFloat(vac) { + expected = int64(vex) + actual = int64(vac) + } + case float64: + if IsWholeFloat(vac) { + expected = int64(vex) + actual = int64(vac) + } + } + case int32: + switch vac := actual.(type) { + case int: + expected = int64(vex) + actual = int64(vac) + case int32: + // same + case int64: + expected = int64(vex) + case float32: + if IsWholeFloat(vac) { + expected = int64(vex) + actual = int64(vac) + } + case float64: + if IsWholeFloat(vac) { + expected = int64(vex) + actual = int64(vac) + } + } + case int64: + switch vac := actual.(type) { + case int: + actual = int64(vac) + case int32: + actual = int64(vac) + case int64: + // same + case float32: + if IsWholeFloat(vac) { + actual = int64(vac) + } + case float64: + if IsWholeFloat(vac) { + actual = int64(vac) + } + } + case float32: + switch vac := actual.(type) { + case int: + if IsWholeFloat(vex) { + expected = int64(vex) + actual = int64(vac) + } + case int32: + if IsWholeFloat(vex) { + expected = int64(vex) + actual = int64(vac) + } + case int64: + if IsWholeFloat(vex) { + expected = int64(vex) + } + case float32: + // same + case float64: + expected = float64(vex) + } + case float64: + switch vac := actual.(type) { + case int: + if IsWholeFloat(vex) { + expected = int64(vex) + actual = int64(vac) + } + case int32: + if IsWholeFloat(vex) { + expected = int64(vex) + actual = int64(vac) + } + case int64: + if IsWholeFloat(vex) { + expected = int64(vex) + } + case float32: + actual = float64(vac) + case float64: + // same + } + + } + if expected != actual { t.Errorf("Value [%s] differs (%T <-> %T):\n", key, expected, actual) @@ -226,3 +332,8 @@ func AssertMappedSet[T langext.OrderedConstraint](t *testing.T, key string, expe t.FailNow() } } + +func IsWholeFloat[T langext.FloatConstraint](v T) bool { + _, frac := math.Modf(math.Abs(float64(v))) + return frac == 0.0 +}