Go-Forward/queue_test.go at master · ClearcodeHQ/Go-Forward · 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
package main

import (
	"sort"
	"testing"

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

func Test_queue_empty(t *testing.T) {
	queue := &eventQueue{max_size: 1}
	assert.True(t, queue.empty())
}

func Test_queue_not_empty(t *testing.T) {
	queue := &eventQueue{max_size: 1}
	queue.add(logEvent{})
	assert.False(t, queue.empty())
}

func Test_queue_length(t *testing.T) {
	queue := &eventQueue{max_size: 1}
	queue.add(logEvent{})
	assert.Equal(t, 1, queue.num())
}

// Assert that event is added at the end of slice.
func Test_queue_add(t *testing.T) {
	queue := &eventQueue{max_size: 3}
	queue.add(logEvent{msg: "first"})
	queue.add(logEvent{msg: "second"})
	queue.add(logEvent{msg: "third"})
	expected := eventsList{
		logEvent{msg: "first"},
		logEvent{msg: "second"},
		logEvent{msg: "third"},
	}
	assert.Equal(t, expected, queue.events)
}

// Assert that batch is sorted.
func Test_queue_sorted_batch(t *testing.T) {
	queue := &eventQueue{max_size: 2}
	queue.add(logEvent{timestamp: 2})
	queue.add(logEvent{timestamp: 1})
	assert.Equal(t, logEvent{timestamp: 1}, queue.getBatch()[0])
}

// Assert that batch size does not exceed its allowed maximum
func Test_sizeIndex_multi(t *testing.T) {
	events := eventsList{
		logEvent{msg: RandomString(maxEventSize)},
		logEvent{msg: RandomString(maxEventSize)},
		logEvent{msg: RandomString(maxEventSize)},
		logEvent{msg: RandomString(maxEventSize)},
	}
	assert.Equal(t, 3, sizeIndex(events))
}

// Assert that batch time span does not exceed its allowed maximum
func Test_timeIndex_multi(t *testing.T) {
	events := eventsList{
		logEvent{timestamp: maxBatchTimeSpan},
		logEvent{timestamp: maxBatchTimeSpan},
		logEvent{timestamp: maxBatchTimeSpan * 3},
	}
	assert.Equal(t, 2, timeIndex(events))
}

// Assert that batch time span does not exceed its allowed maximum
func Test_timeIndex_single(t *testing.T) {
	events := eventsList{
		logEvent{timestamp: maxBatchTimeSpan},
	}
	assert.Equal(t, 1, timeIndex(events))
}

// Assert that lowest index is returned
func Test_numEvents_min(t *testing.T) {
	events := make(eventsList, 0)
	funcA := func(e eventsList) int { return maxBatchEvents - 1 }
	funcB := func(e eventsList) int { return maxBatchEvents - 2 }
	assert.Equal(t, maxBatchEvents-2, numEvents(events, funcA, funcB))
}

// Assert that maximum index is returned
func Test_numEvents_max(t *testing.T) {
	events := make(eventsList, 0)
	funcA := func(e eventsList) int { return maxBatchEvents }
	funcB := func(e eventsList) int { return maxBatchEvents }
	assert.Equal(t, maxBatchEvents, numEvents(events, funcA, funcB))
}

func Test_eventList_size(t *testing.T) {
	events := eventsList{
		logEvent{msg: "123456"},
		logEvent{msg: "12345"},
		logEvent{msg: "123"},
	}
	assert.Equal(t, 92, events.size())
}

// Assert that events are sorted by timestamp in ascending order
func Test_eventList_Sort(t *testing.T) {
	sorted := eventsList{
		logEvent{timestamp: 1},
		logEvent{timestamp: 2},
	}
	to_sort := eventsList{
		logEvent{timestamp: 2},
		logEvent{timestamp: 1},
	}
	sort.Sort(to_sort)
	assert.Equal(t, sorted, to_sort)
}