bool_test.go

package null

import (
	"encoding/json"
	"errors"
	"testing"

	"github.com/mailru/easyjson"
	"github.com/stretchr/testify/assert"
)

var (
	boolJSON     = []byte(`true`)
	nullBoolJSON = []byte(`{"Bool":true,"Valid":true}`)
)

func TestBoolFrom(t *testing.T) {
	b := BoolFrom(true)
	assertBool(t, b, "BoolFrom()")

	zero := BoolFrom(false)
	if !zero.Valid {
		t.Error("BoolFrom(false)", "is invalid, but should be valid")
	}
}

func TestBoolFromPtr(t *testing.T) {
	n := true
	bptr := &n
	b := BoolFromPtr(bptr)
	assertBool(t, b, "BoolFromPtr()")

	bptr = nil
	null := BoolFromPtr(bptr)
	assertNullBool(t, null, "BoolFromPtr(nil)")
}

func TestUnmarshalBool(t *testing.T) {
	var b Bool
	err := json.Unmarshal(boolJSON, &b)
	maybePanic(err)
	assertBool(t, b, "bool json")

	var nb Bool
	err = json.Unmarshal(nullBoolJSON, &nb)
	maybePanic(err)

	var null Bool
	err = json.Unmarshal(nullJSON, &null)
	maybePanic(err)
	assertNullBool(t, null, "null json")

	var empty Bool
	var data []byte
	err = empty.UnmarshalJSON(data)
	maybePanic(err)
	assertNullBool(t, empty, "null json")

	var badType Bool
	err = json.Unmarshal(intJSON, &badType)
	if err == nil {
		panic("err should not be nil")
	}
	assertNullBool(t, badType, "wrong type json")

	var invalid Bool
	err = invalid.UnmarshalJSON(invalidJSON)
	var syntaxError *json.SyntaxError
	if !errors.As(err, &syntaxError) {
		t.Errorf("expected wrapped json.SyntaxError, not %T", err)
	}
}

func TestTextUnmarshalBool(t *testing.T) {
	var b Bool
	err := b.UnmarshalText([]byte("true"))
	maybePanic(err)
	assertBool(t, b, "UnmarshalText() bool")

	var zero Bool
	err = zero.UnmarshalText([]byte("false"))
	maybePanic(err)
	assertFalseBool(t, zero, "UnmarshalText() false")

	var blank Bool
	err = blank.UnmarshalText([]byte(""))
	maybePanic(err)
	assertNullBool(t, blank, "UnmarshalText() empty bool")

	var null Bool
	err = null.UnmarshalText(nullLiteral)
	maybePanic(err)
	assertNullBool(t, null, `UnmarshalText() "null"`)

	var invalid Bool
	err = invalid.UnmarshalText([]byte(":D"))
	if err == nil {
		panic("err should not be nil")
	}
	assertNullBool(t, invalid, "invalid json")
}

func TestMarshalBool(t *testing.T) {
	b := BoolFrom(true)
	data, err := json.Marshal(b)
	maybePanic(err)
	assertJSONEquals(t, data, "true", "non-empty json marshal")

	zero := NewBool(false, true)
	data, err = json.Marshal(zero)
	maybePanic(err)
	assertJSONEquals(t, data, "false", "zero json marshal")

	// invalid values should be encoded as null
	null := NewBool(false, false)
	data, err = json.Marshal(null)
	maybePanic(err)
	assertJSONEquals(t, data, "null", "null json marshal")
}

func TestMarshalBoolText(t *testing.T) {
	b := BoolFrom(true)
	data, err := b.MarshalText()
	maybePanic(err)
	assertJSONEquals(t, data, "true", "non-empty text marshal")

	zero := NewBool(false, true)
	data, err = zero.MarshalText()
	maybePanic(err)
	assertJSONEquals(t, data, "false", "zero text marshal")

	// invalid values should be encoded as null
	null := NewBool(false, false)
	data, err = null.MarshalText()
	maybePanic(err)
	assertJSONEquals(t, data, "", "null text marshal")
}

func TestBoolPointer(t *testing.T) {
	b := BoolFrom(true)
	ptr := b.Ptr()
	if *ptr != true {
		t.Errorf("bad %s bool: %#v ≠ %v\n", "pointer", ptr, true)
	}

	null := NewBool(false, false)
	ptr = null.Ptr()
	if ptr != nil {
		t.Errorf("bad %s bool: %#v ≠ %s\n", "nil pointer", ptr, "nil")
	}
}

func TestBoolIsZero(t *testing.T) {
	b := BoolFrom(true)
	if b.IsZero() {
		t.Errorf("IsZero() should be false")
	}

	null := NewBool(false, false)
	if !null.IsZero() {
		t.Errorf("IsZero() should be true")
	}

	zero := NewBool(false, true)
	if zero.IsZero() {
		t.Errorf("IsZero() should be false")
	}
}

func TestBoolSetValid(t *testing.T) {
	change := NewBool(false, false)
	assertNullBool(t, change, "SetValid()")
	change.SetValid(true)
	assertBool(t, change, "SetValid()")
}

func TestBoolScan(t *testing.T) {
	var b Bool
	err := b.Scan(true)
	maybePanic(err)
	assertBool(t, b, "scanned bool")

	var null Bool
	err = null.Scan(nil)
	maybePanic(err)
	assertNullBool(t, null, "scanned null")
}

func TestBoolValueOrZero(t *testing.T) {
	valid := NewBool(true, true)
	if valid.ValueOrZero() != true {
		t.Error("unexpected ValueOrZero", valid.ValueOrZero())
	}

	invalid := NewBool(true, false)
	if invalid.ValueOrZero() != false {
		t.Error("unexpected ValueOrZero", invalid.ValueOrZero())
	}
}

func TestBoolEqual(t *testing.T) {
	b1 := NewBool(true, false)
	b2 := NewBool(true, false)
	assertBoolEqualIsTrue(t, b1, b2)

	b1 = NewBool(true, false)
	b2 = NewBool(false, false)
	assertBoolEqualIsTrue(t, b1, b2)

	b1 = NewBool(true, true)
	b2 = NewBool(true, true)
	assertBoolEqualIsTrue(t, b1, b2)

	b1 = NewBool(true, true)
	b2 = NewBool(true, false)
	assertBoolEqualIsFalse(t, b1, b2)

	b1 = NewBool(true, false)
	b2 = NewBool(true, true)
	assertBoolEqualIsFalse(t, b1, b2)

	b1 = NewBool(true, true)
	b2 = NewBool(false, true)
	assertBoolEqualIsFalse(t, b1, b2)
}

func TestUnderlyingBool(t *testing.T) {
	type foo bool
	const val bool = true
	f := foo(val)
	nullF := B(f)
	if !nullF.Valid {
		t.Fatalf("expected the null.Bool to be valid")
	}
	if act := nullF.Bool; val != act {
		t.Fatalf("expected %v, but given %v", val, act)
	}
}

func assertBool(t *testing.T, b Bool, from string) {
	if b.Bool != true {
		t.Errorf("bad %s bool: %v ≠ %v\n", from, b.Bool, true)
	}
	if !b.Valid {
		t.Error(from, "is invalid, but should be valid")
	}
}

func assertFalseBool(t *testing.T, b Bool, from string) {
	if b.Bool != false {
		t.Errorf("bad %s bool: %v ≠ %v\n", from, b.Bool, false)
	}
	if !b.Valid {
		t.Error(from, "is invalid, but should be valid")
	}
}

func assertNullBool(t *testing.T, b Bool, from string) {
	if b.Valid {
		t.Error(from, "is valid, but should be invalid")
	}
}

func TestBoolUnmarshalEasyJSON(t *testing.T) {
	tests := []struct {
		data string
		exp  Bool
	}{
		{
			data: "null",
		},
		{
			data: `true`,
			exp:  BoolFrom(true),
		},
		{
			data: `false`,
			exp:  BoolFrom(false),
		},

		{
			data: `{"Bool":false,"Valid":true}`,
			exp:  BoolFrom(false),
		},
		{
			data: `{"bool":true,"valid":true}`,
			exp:  BoolFrom(true),
		},
	}

	for _, test := range tests {
		t.Run(test.data, func(t *testing.T) {
			var b1 Bool
			assert.NoError(t, easyjson.Unmarshal([]byte(test.data), &b1))
			assert.Equal(t, test.exp, b1)

			var b2 Bool
			assert.NoError(t, json.Unmarshal([]byte(test.data), &b2))
			assert.Equal(t, test.exp, b2)
		})
	}
}

func assertBoolEqualIsTrue(t *testing.T, a, b Bool) {
	t.Helper()
	if !a.Equal(b) {
		t.Errorf("Equal() of Bool{%t, Valid:%t} and Bool{%t, Valid:%t} should return true", a.Bool, a.Valid, b.Bool, b.Valid)
	}
}

func assertBoolEqualIsFalse(t *testing.T, a, b Bool) {
	t.Helper()
	if a.Equal(b) {
		t.Errorf("Equal() of Bool{%t, Valid:%t} and Bool{%t, Valid:%t} should return false", a.Bool, a.Valid, b.Bool, b.Valid)
	}
}

func TestTrueFalse(t *testing.T) {
	assert.True(t, True().Valid)
	assert.True(t, True().Bool)
	assert.True(t, False().Valid)
	assert.False(t, False().Bool)
}