ordereddict_test.go

package ordereddict

import (
	"encoding/json"
	"fmt"
	"reflect"
	"sync/atomic"
	"testing"
	"time"

	"github.com/alecthomas/repr"
	"github.com/stretchr/testify/assert"
)

type dictSerializationTest struct {
	dict       *Dict
	serialized string
}

var (
	dictSerializationTests = []dictSerializationTest{
		{NewDict().Set("Foo", "Bar"), `{"Foo":"Bar"}`},

		// Test an unserilizable member - This should not prevent the
		// entire dict from serializing - only that member should be
		// ignored.
		{NewDict().Set("Foo", "Bar").
			Set("Time", time.Unix(3000000000000000, 0)),
			`{"Foo":"Bar","Time":null}`},

		// Recursive dict
		{NewDict().Set("Foo",
			NewDict().Set("Bar", 2).
				Set("Time", time.Unix(3000000000000000, 0))),
			`{"Foo":{"Bar":2,"Time":null}}`},

		// Ensure key order is preserved.
		{NewDict().Set("A", 1).Set("B", 2), `{"A":1,"B":2}`},
		{NewDict().Set("B", 1).Set("A", 2), `{"B":1,"A":2}`},

		// Serialize with quotes
		{NewDict().Set("foo\\'s quote", 1), `{"foo\\'s quote":1}`},
	}

	// Check that serialization decodes to the object.
	dictUnserializationTest = []dictSerializationTest{
		// Preserve order of keys on deserialization.
		{NewDict().Set("A", uint64(1)).Set("B", uint64(2)), `{"A":1,"B":2}`},
		{NewDict().Set("B", uint64(1)).Set("A", uint64(2)), `{"B":1,"A":2}`},

		// Handle arrays, ints floats and bools
		{NewDict().Set("B", uint64(1)).Set("A", uint64(2)), `{"B":1,"A":2}`},
		{NewDict().Set("B", float64(1)).Set("A", uint64(2)), `{"B":1.0,"A":2}`},
		{NewDict().Set("B", []interface{}{uint64(1)}).Set("A", uint64(2)), `{"B":[1],"A":2}`},
		{NewDict().Set("B", true).Set("A", uint64(2)), `{"B":true,"A":2}`},
		{NewDict().Set("B", nil).Set("A", uint64(2)), `{"B":null,"A":2}`},

		// Embedded dicts decode into ordered dicts.
		{NewDict().
			Set("B", NewDict().Set("Zoo", "X").Set("Baz", "Y")).
			Set("A", "Z"), `{"B":{"Zoo":"X","Baz":"Y"},"A":"Z"}`},

		// Make sure we properly preserve uint64 (overflows int64)
		{NewDict().
			Set("Uint64", uint64(9223372036854775808)),
			`{"Uint64": 9223372036854775808}`},

		// We prefer uint64 but int64 is needed for negative numbers
		{NewDict().
			Set("Int64", int64(-500)),
			`{"Int64": -500}`},
	}
)

func TestDictSerialization(t *testing.T) {
	for _, test := range dictSerializationTests {
		serialized, err := json.Marshal(test.dict)
		if err != nil {
			t.Fatalf("Failed to serialize %v: %v", repr.String(test.dict), err)
		}

		assert.Equal(t, test.serialized, string(serialized))
	}
}

func TestDictDeserialization(t *testing.T) {
	for _, test := range dictUnserializationTest {
		value := NewDict()

		err := json.Unmarshal([]byte(test.serialized), value)
		if err != nil {
			t.Fatalf("Failed to serialize %v: %v", test.serialized, err)
		}
		// Make sure the keys are the same.
		assert.Equal(t, test.dict.Keys(), value.Keys())
		assert.Equal(t, test.dict.ToMap(), value.ToMap())

		assert.True(t, reflect.DeepEqual(test.dict, value))
	}
}

func TestTimestampDeserialization(t *testing.T) {
	serialized := `{"Time":"2022-08-21T03:08:45.076884Z", "Time2":"2022-08-21T03:08:45.076884+07:00"}`
	value := NewDict()
	err := json.Unmarshal([]byte(serialized), value)
	assert.NoError(t, err)

	t1_any, pres := value.Get("Time")
	assert.True(t, pres)

	t1, ok := t1_any.(time.Time)
	assert.True(t, ok)
	assert.Equal(t, int64(1661051325), t1.Unix())

	t2_any, pres := value.Get("Time2")
	assert.True(t, pres)

	t2, ok := t2_any.(time.Time)
	assert.True(t, ok)
	assert.Equal(t, int64(1661026125), t2.Unix())

}

func TestOrder(t *testing.T) {
	test := NewDict().
		Set("A", 1).
		Set("B", 2)

	assert.Equal(t, []string{"A", "B"}, test.Keys())

	test = NewDict().
		Set("B", 1).
		Set("A", 2)

	assert.Equal(t, []string{"B", "A"}, test.Keys())
}

func TestDelete(t *testing.T) {
	test := NewDict().
		Set("A", 1).
		Set("B", 2).
		Set("C", 3)
	test.Delete("B")

	assert.Equal(t, []string{"A", "C"}, test.Keys())
	assert.Equal(t, 2, test.Len())
}

func TestDeleteCompactions(t *testing.T) {
	clearCompactions()

	CompactionThreashold = 10
	test := NewDict()
	for i := 0; i < 20; i++ {
		key := fmt.Sprintf("Key%d", i)
		test.Set(key, i)
	}
	// No compactions when setting fresh keys
	assert.Equal(t, uint64(0), getCompactions())

	// Setting always reorders the dict, since Set must update the
	// key's order. This is equivalent to Delete() +
	// Update(). Repeated setting of the same key will cause a lot of
	// compactions - consider using Update() instead.
	for i := 0; i < 20; i++ {
		key := fmt.Sprintf("Key%d", i)
		test.Set(key, i)
	}
	// Two compactions cycles every 10 keys
	assert.Equal(t, uint64(2), getCompactions())

	// Deleting keys will also cause compactions
	for i := 0; i < 20; i++ {
		key := fmt.Sprintf("Key%d", i)
		test.Delete(key)
	}

	// We should rebalance twice - every 10 deletions.
	assert.Equal(t, uint64(4), getCompactions())
}

func TestAliases(t *testing.T) {
	test := NewDict().
		Set("A", 1).
		Set("B", 2).
		Set("C", 3)
	test.AliasField("Foo", "A")

	assert.Equal(t, []string{"A", "B", "C"}, test.Keys())
	assert.Equal(t, 3, test.Len())

	value, ok := test.Get("Foo")
	assert.True(t, ok)
	assert.Equal(t, 1, value)
}

func TestDefault(t *testing.T) {
	test := NewDict().
		SetDefault("Default").
		SetCaseInsensitive().
		Set("A", 1).
		Set("B", 2).
		Set("C", 3)

	value, pres := test.Get("a")
	assert.True(t, pres)
	assert.Equal(t, 1, value)
}

func TestCaseInsensitive(t *testing.T) {
	test := NewDict().SetCaseInsensitive()

	test.Set("FOO", 1)

	value, pres := test.Get("foo")
	assert.True(t, pres)
	assert.Equal(t, 1, value)

	test = NewDict().Set("FOO", 1)
	value, pres = test.Get("foo")
	assert.False(t, pres)
}

func clearCompactions() {
	atomic.StoreUint64(&Compactions, 0)
}

func getCompactions() uint64 {
	return atomic.LoadUint64(&Compactions)
}