[🤖] Add Unit-Tests

sq/converterDefault_test.go

@@ -0,0 +1,199 @@
+package sq
+
+import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/rfctime"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"testing"
+	"time"
+)
+
+func TestConverterBoolToBit(t *testing.T) {
+	v, err := ConverterBoolToBit.ModelToDB(true)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, int64(1), v.(int64))
+
+	v, err = ConverterBoolToBit.ModelToDB(false)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, int64(0), v.(int64))
+
+	v, err = ConverterBoolToBit.DBToModel(int64(1))
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, true, v.(bool))
+
+	v, err = ConverterBoolToBit.DBToModel(int64(0))
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, false, v.(bool))
+
+	_, err = ConverterBoolToBit.DBToModel(int64(2))
+	if err == nil {
+		t.Fatal("expected error for value not in {0,1}")
+	}
+}
+
+func TestConverterTimeToUnixMillis(t *testing.T) {
+	t0 := time.Date(2024, 6, 15, 12, 34, 56, int(789*time.Millisecond), time.UTC)
+	expected := t0.UnixMilli()
+
+	v, err := ConverterTimeToUnixMillis.ModelToDB(t0)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(int64))
+
+	v, err = ConverterTimeToUnixMillis.DBToModel(expected)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(time.Time).UnixMilli())
+}
+
+func TestConverterRFCUnixMilliTime(t *testing.T) {
+	t0 := rfctime.NewUnixMilli(time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC))
+	expected := t0.UnixMilli()
+
+	v, err := ConverterRFCUnixMilliTimeToUnixMillis.ModelToDB(t0)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(int64))
+
+	v, err = ConverterRFCUnixMilliTimeToUnixMillis.DBToModel(expected)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(rfctime.UnixMilliTime).UnixMilli())
+}
+
+func TestConverterRFCUnixNanoTime(t *testing.T) {
+	t0 := rfctime.NewUnixNano(time.Date(2020, 1, 2, 3, 4, 5, 123456789, time.UTC))
+	expected := t0.UnixNano()
+
+	v, err := ConverterRFCUnixNanoTimeToUnixNanos.ModelToDB(t0)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(int64))
+
+	v, err = ConverterRFCUnixNanoTimeToUnixNanos.DBToModel(expected)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(rfctime.UnixNanoTime).UnixNano())
+}
+
+func TestConverterRFCUnixTime(t *testing.T) {
+	t0 := rfctime.NewUnix(time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC))
+	expected := t0.Unix()
+
+	v, err := ConverterRFCUnixTimeToUnixSeconds.ModelToDB(t0)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(int64))
+
+	v, err = ConverterRFCUnixTimeToUnixSeconds.DBToModel(expected)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, expected, v.(rfctime.UnixTime).Unix())
+}
+
+func TestConverterRFC339Time(t *testing.T) {
+	t0 := rfctime.NewRFC3339(time.Date(2020, 6, 15, 9, 30, 45, 0, time.UTC))
+
+	v, err := ConverterRFC339TimeToString.ModelToDB(t0)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, "2020-06-15 09:30:45", v.(string))
+
+	v, err = ConverterRFC339TimeToString.DBToModel("2020-06-15 09:30:45")
+	tst.AssertNoErr(t, err)
+	tt := v.(rfctime.RFC3339Time).Time().UTC()
+	tst.AssertEqual(t, 2020, tt.Year())
+	tst.AssertEqual(t, time.June, tt.Month())
+	tst.AssertEqual(t, 15, tt.Day())
+	tst.AssertEqual(t, 9, tt.Hour())
+	tst.AssertEqual(t, 30, tt.Minute())
+	tst.AssertEqual(t, 45, tt.Second())
+
+	_, err = ConverterRFC339TimeToString.DBToModel("garbage")
+	if err == nil {
+		t.Fatal("expected parse error")
+	}
+}
+
+func TestConverterRFC339NanoTime(t *testing.T) {
+	t0 := rfctime.NewRFC3339Nano(time.Date(2020, 6, 15, 9, 30, 45, 123456789, time.UTC))
+
+	v, err := ConverterRFC339NanoTimeToString.ModelToDB(t0)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, "2020-06-15 09:30:45.123456789", v.(string))
+
+	v, err = ConverterRFC339NanoTimeToString.DBToModel("2020-06-15 09:30:45.123456789")
+	tst.AssertNoErr(t, err)
+	tt := v.(rfctime.RFC3339NanoTime).Time().UTC()
+	tst.AssertEqual(t, 123456789, tt.Nanosecond())
+
+	_, err = ConverterRFC339NanoTimeToString.DBToModel("not a date")
+	if err == nil {
+		t.Fatal("expected parse error")
+	}
+}
+
+func TestConverterRFCDate(t *testing.T) {
+	d := rfctime.Date{Year: 2024, Month: 3, Day: 9}
+	v, err := ConverterRFCDateToString.ModelToDB(d)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, "2024-03-09", v.(string))
+
+	v, err = ConverterRFCDateToString.DBToModel("2024-03-09")
+	tst.AssertNoErr(t, err)
+	d2 := v.(rfctime.Date)
+	tst.AssertEqual(t, 2024, d2.Year)
+	tst.AssertEqual(t, 3, d2.Month)
+	tst.AssertEqual(t, 9, d2.Day)
+
+	_, err = ConverterRFCDateToString.DBToModel("invalid")
+	if err == nil {
+		t.Fatal("expected parse error")
+	}
+}
+
+func TestConverterRFCTime(t *testing.T) {
+	tm := rfctime.NewTime(13, 30, 45, 0)
+	v, err := ConverterRFCTimeToString.ModelToDB(tm)
+	tst.AssertNoErr(t, err)
+	roundtrip, err := ConverterRFCTimeToString.DBToModel(v.(string))
+	tst.AssertNoErr(t, err)
+	tm2 := roundtrip.(rfctime.Time)
+	tst.AssertEqual(t, 13, tm2.Hour)
+	tst.AssertEqual(t, 30, tm2.Minute)
+	tst.AssertEqual(t, 45, tm2.Second)
+
+	_, err = ConverterRFCTimeToString.DBToModel("xx:xx:xx")
+	if err == nil {
+		t.Fatal("expected parse error")
+	}
+}
+
+func TestConverterRFCSecondsF64(t *testing.T) {
+	d := 12*time.Second + 500*time.Millisecond
+	s := rfctime.NewSecondsF64(d)
+	v, err := ConverterRFCSecondsF64ToString.ModelToDB(s)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, 12.5, v.(float64))
+
+	v, err = ConverterRFCSecondsF64ToString.DBToModel(12.5)
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, 12.5, v.(rfctime.SecondsF64).Seconds())
+}
+
+func TestConverterJsonObjToString(t *testing.T) {
+	tst.AssertEqual(t, "sq.JsonObj", ConverterJsonObjToString.ModelTypeString())
+	tst.AssertEqual(t, "string", ConverterJsonObjToString.DBTypeString())
+
+	v, err := ConverterJsonObjToString.ModelToDB(JsonObj{"x": float64(1)})
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, `{"x":1}`, v.(string))
+
+	r, err := ConverterJsonObjToString.DBToModel(`{"x":1}`)
+	tst.AssertNoErr(t, err)
+	tst.AssertStrRepEqual(t, r.(JsonObj)["x"], float64(1))
+}
+
+func TestConverterJsonArrToString(t *testing.T) {
+	tst.AssertEqual(t, "sq.JsonArr", ConverterJsonArrToString.ModelTypeString())
+	tst.AssertEqual(t, "string", ConverterJsonArrToString.DBTypeString())
+
+	v, err := ConverterJsonArrToString.ModelToDB(JsonArr{float64(1), float64(2)})
+	tst.AssertNoErr(t, err)
+	tst.AssertEqual(t, `[1,2]`, v.(string))
+
+	r, err := ConverterJsonArrToString.DBToModel(`[1,2]`)
+	tst.AssertNoErr(t, err)
+	arr := r.(JsonArr)
+	tst.AssertEqual(t, 2, len(arr))
+}