Created

jsonx/json_test.go

@@ -0,0 +1,166 @@
+package jsonx
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"strings"
+	"testing"
+)
+
+func TestToJson(t *testing.T) {
+	var names []string
+	testCases := []struct {
+		Number       int
+		Value        interface{}
+		DefaultValue string
+		Except       string
+	}{
+		{1, []string{}, "[]", "[]"},
+		{2, struct{}{}, "", "{}"},
+		{3, struct {
+			Name string
+			Age  int
+		}{"Hello", 12}, "", `{"Name":"hello","Age":12}`},
+		{4, struct {
+			Name string `json:"a"`
+			Age  int    `json:"b"`
+		}{"Hello", 12}, "", `{"a":"hello","b":12}`},
+		{5, nil, "abc", "abc"},
+		{6, []int{1, 2}, "null", "[1,2]"},
+		{7, []string{"a", "b"}, "null", `["a","b"]`},
+		{8, 1, "[]", "1"},
+		{9, "abc", "[]", `"abc"`},
+		{10, nil, "[]", `[]`},
+		{11, names, "[]", `[]`},
+	}
+	for _, testCase := range testCases {
+		s := ToJson(testCase.Value, testCase.DefaultValue)
+		if !strings.EqualFold(s, testCase.Except) {
+			t.Errorf("%d %#v except: %s actual: %s", testCase.Number, testCase.Value, testCase.Except, s)
+		}
+	}
+}
+
+func TestEmptyObject(t *testing.T) {
+	result := "{}"
+	if b, err := EmptyObjectRawMessage().MarshalJSON(); err == nil {
+		eValue := string(b)
+		if !strings.EqualFold(eValue, result) {
+			t.Errorf("Excepted value: %s, actual value: %s", eValue, result)
+		}
+	} else {
+		t.Errorf("Error: %s", err.Error())
+	}
+}
+
+func TestEmptyArray(t *testing.T) {
+	result := "[]"
+	if b, err := EmptyArrayRawMessage().MarshalJSON(); err == nil {
+		eValue := string(b)
+		if !strings.EqualFold(eValue, result) {
+			t.Errorf("Excepted value: %s, actual value: %s", eValue, result)
+		}
+	} else {
+		t.Errorf("Error: %s", err.Error())
+	}
+}
+
+func TestIsEmptyRawMessage(t *testing.T) {
+	type testCase struct {
+		Number int
+		Value  json.RawMessage
+		Empty  bool
+	}
+	v1, _ := ToRawMessage([]string{}, "[]")
+	v2, _ := ToRawMessage([]string{"a", "b"}, "[]")
+	v3, _ := ToRawMessage([]int{1, 2, 3}, "[]")
+	v4, _ := ToRawMessage(struct {
+		Name string
+		Age  int
+	}{"John", 10}, "{}")
+	v5, _ := ToRawMessage(nil, "[]")
+	a := json.RawMessage{}
+	a.UnmarshalJSON([]byte("null"))
+	b := json.RawMessage{}
+	b.UnmarshalJSON([]byte(""))
+	c := json.RawMessage{}
+	c.UnmarshalJSON([]byte("[    ]"))
+	testCases := []testCase{
+		{1, json.RawMessage{}, true},
+		{2, EmptyObjectRawMessage(), true},
+		{3, EmptyArrayRawMessage(), true},
+		{4, v1, true},
+		{5, v2, false},
+		{6, v3, false},
+		{7, v4, false},
+		{8, v5, true},
+		{9, a, true},
+		{10, b, true},
+		{11, c, true},
+	}
+
+	for _, tc := range testCases {
+		v := IsEmptyRawMessage(tc.Value)
+		if v != tc.Empty {
+			t.Errorf("%d except: %v, actual: %v", tc.Number, tc.Empty, v)
+		}
+	}
+}
+
+func TestConvert(t *testing.T) {
+	testCases := []struct {
+		Number int
+		From   json.RawMessage
+		Except any
+	}{
+		{1, nil, struct{}{}},
+		{2, EmptyArrayRawMessage(), []struct{}{}},
+		{3, []byte(`{"ID":1,"Name":"hiscaler"}`), struct {
+			ID   int
+			Name string
+		}{}},
+		{4, []byte(`{"ID":1,"Name":"hiscaler","age":1}`), struct {
+			ID   int
+			Name string
+			age  int
+		}{}},
+	}
+	for _, testCase := range testCases {
+		exceptValue := testCase.Except
+		err := Convert(testCase.From, &exceptValue)
+		assert.Equalf(t, nil, err, "Test %d", testCase.Number)
+		actualValue := ""
+		if testCase.From != nil {
+			actualValue = ToJson(exceptValue, "null")
+		}
+		t.Logf(`
+#%d %s
+    ↓
+    %#v`, testCase.Number, testCase.From, exceptValue)
+		assert.Equalf(t, string(testCase.From), actualValue, "Test %d", testCase.Number)
+	}
+}
+
+func TestExtract(t *testing.T) {
+	testCases := []struct {
+		Number   int
+		From     string
+		Except   string
+		HasError bool
+	}{
+		{1, "", "", true},
+		{2, "{}", "{}", false},
+		{3, "  {}   ", "{}", false},
+		{4, `{"a": 1, "b": 2}`, `{"a": 1, "b": 2}`, false},
+		{5, `{"a": 1, "b": 2}}}}a`, `{"a": 1, "b": 2}`, false},
+		{6, `{"a": 1, "b": 2}}}}<!--This page has been excluded -->`, `{"a": 1, "b": 2}`, false},
+		{7, "[]", "[]", false},
+		{8, "[]1[]2", "[]", false},
+	}
+	for _, testCase := range testCases {
+		exceptValue := testCase.Except
+		actualValue, err := Extract(testCase.From)
+		assert.Equalf(t, testCase.HasError, err != nil, "Test HasError %d", testCase.Number)
+		assert.Equalf(t, exceptValue, actualValue, "Test Value %d", testCase.Number)
+	}
+}