shared/vars_test.go at master · bool64/shared · 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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package shared_test

import (
	"context"
	"encoding/json"
	"sync"
	"testing"

	"github.com/bool64/shared"
	"github.com/stretchr/testify/assert"
)

func TestVars_GetAll(t *testing.T) {
	v := shared.Vars{}
	cnt := 0

	v.OnSet(func(key string, val interface{}) {
		assert.Equal(t, "k", key)
		assert.Equal(t, "v", val)

		cnt++
	})

	v.Set("k", "v")
	val, found := v.Get("k")
	assert.True(t, found)
	assert.Equal(t, "v", val)

	assert.Equal(t, map[string]interface{}{"k": "v"}, v.GetAll())
	assert.True(t, v.IsVar("$var"))
	assert.False(t, v.IsVar("var"))
	assert.Equal(t, 1, cnt)

	v.Reset()
	assert.Equal(t, map[string]interface{}{}, v.GetAll())
}

func TestVars_Fork(t *testing.T) {
	v := shared.Vars{}
	v.Set("k", "v")

	wg := sync.WaitGroup{}

	for i := 0; i < 50; i++ {
		i := i

		wg.Add(1)

		go func() {
			defer wg.Done()

			ctx, vi := v.Fork(context.Background())

			assert.Equal(t, map[string]interface{}{"k": "v"}, vi.GetAll())
			vi.Set("ki", i)
			assert.Equal(t, map[string]interface{}{"k": "v", "ki": i}, vi.GetAll())
			vi.Set("k", i)
			assert.Equal(t, map[string]interface{}{"k": i, "ki": i}, vi.GetAll())

			// Forking with already instrumented context is a no op.
			ctx2, vi2 := v.Fork(ctx)
			assert.Equal(t, ctx, ctx2)
			assert.Equal(t, vi, vi2)
		}()
	}

	assert.Equal(t, map[string]interface{}{"k": "v"}, v.GetAll())
}

func TestVarToContext(t *testing.T) {
	ctx := context.Background()
	ctx = shared.VarToContext(ctx, "$foo", "bar")

	assert.Equal(t, map[string]interface{}{"$foo": "bar"}, shared.VarsFromContext(ctx))

	var nilParent *shared.Vars

	npCtx, vv := nilParent.Fork(ctx)
	assert.Equal(t, map[string]interface{}{"$foo": "bar"}, shared.VarsFromContext(npCtx))
	assert.Equal(t, map[string]interface{}{"$foo": "bar"}, vv.GetAll())

	parent := shared.Vars{}
	parent.Set("$baz", "qux")

	pCtx, vv := parent.Fork(ctx)
	assert.Equal(t, map[string]interface{}{"$foo": "bar", "$baz": "qux"}, shared.VarsFromContext(pCtx))
	assert.Equal(t, map[string]interface{}{"$foo": "bar", "$baz": "qux"}, vv.GetAll())

	ctx = shared.VarToContext(pCtx, "$quux", true)
	assert.Equal(t, map[string]interface{}{"$foo": "bar", "$baz": "qux", "$quux": true}, shared.VarsFromContext(ctx))
}

func TestDecodeJSONNumber(t *testing.T) {
	assert.Equal(t, int64(1), shared.DecodeJSONNumber("1"))
	assert.Equal(t, int64(-1), shared.DecodeJSONNumber("-1"))
	assert.Equal(t, 1.0, shared.DecodeJSONNumber("1.0"))
	assert.Equal(t, 1.23, shared.DecodeJSONNumber("1.23"))
	assert.Equal(t, uint64(17294094973108486143), shared.DecodeJSONNumber("17294094973108486143"))
}

func TestVars_Set_jsonNumber(t *testing.T) {
	v := shared.Vars{}

	val := map[string]interface{}{
		"foo": json.Number("123"),
		"bar": json.Number("123.456"),
		"baz": []interface{}{json.Number("123"), json.Number("123.456"), 789},
	}

	v.Set("test", val)

	val2, ok := v.Get("test")
	assert.True(t, ok)
	assert.Equal(t, map[string]interface{}{
		"foo": int64(123),
		"bar": 123.456,
		"baz": []interface{}{int64(123), 123.456, 789},
	}, val2)
}