form/sql_test.go at master · swaggest/form · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package form_test

import (
	"database/sql"
	"testing"

	assert "github.com/stretchr/testify/assert"
	"github.com/swaggest/form/v5"
)

type TestNullTypes struct {
	I sql.NullInt64   `db:"i"`
	F sql.NullFloat64 `db:"f"`
	S sql.NullString  `db:"s"`
	B sql.NullBool    `db:"b"`
}

func TestRegisterSQLNullTypesEncodeFunc(t *testing.T) {
	t.Parallel()

	e := form.NewEncoder()
	e.SetMode(form.ModeExplicit)
	e.SetTagName("db")
	form.RegisterSQLNullTypesEncodeFunc(e, "NULL")

	testNullTypes := TestNullTypes{}
	v, err := e.Encode(testNullTypes)
	assert.Equal(t, err, nil)
	assert.Equal(t, v["i"], []string{"NULL"})
	assert.Equal(t, v["f"], []string{"NULL"})
	assert.Equal(t, v["s"], []string{"NULL"})
	assert.Equal(t, v["b"], []string{"NULL"})

	testNullTypes = TestNullTypes{
		I: sql.NullInt64{Int64: 123, Valid: true},
		F: sql.NullFloat64{Float64: 123.456, Valid: true},
		S: sql.NullString{String: "abc", Valid: true},
		B: sql.NullBool{Bool: false, Valid: true},
	}

	v, err = e.Encode(testNullTypes)
	assert.Equal(t, err, nil)
	assert.Equal(t, v["i"], []string{"123"})
	assert.Equal(t, v["f"], []string{"123.456"})
	assert.Equal(t, v["s"], []string{"abc"})
	assert.Equal(t, v["b"], []string{"false"})
}

func TestRegisterSQLNullTypesDecodeFunc(t *testing.T) {
	t.Parallel()

	d := form.NewDecoder()
	d.SetMode(form.ModeExplicit)
	d.SetTagName("db")
	form.RegisterSQLNullTypesDecodeFunc(d, "NULL", "null")

	v := map[string][]string{
		"i": {"NULL"},
		"f": {"NULL"},
		"s": {"NULL"},
		"b": {"null"},
	}
	testNullTypes := TestNullTypes{}

	err := d.Decode(&testNullTypes, v)
	assert.Equal(t, err, nil)
	assert.Equal(t, testNullTypes.I.Valid, false)
	assert.Equal(t, testNullTypes.F.Valid, false)
	assert.Equal(t, testNullTypes.S.Valid, false)
	assert.Equal(t, testNullTypes.B.Valid, false)

	v = map[string][]string{
		"i": {"123"},
		"f": {"123.456"},
		"s": {"abc"},
		"b": {"false"},
	}

	err = d.Decode(&testNullTypes, v)
	assert.Equal(t, err, nil)
	assert.Equal(t, testNullTypes.I.Int64, int64(123))
	assert.Equal(t, testNullTypes.F.Float64, 123.456)
	assert.Equal(t, testNullTypes.S.String, "abc")
	assert.Equal(t, testNullTypes.B.Bool, false)
}