You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
114 lines
2.2 KiB
Go
114 lines
2.2 KiB
Go
package executors
|
|
|
|
import (
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestBulkExecutor(t *testing.T) {
|
|
var values []int
|
|
var lock sync.Mutex
|
|
|
|
exeutor := NewBulkExecutor(func(items []interface{}) {
|
|
lock.Lock()
|
|
values = append(values, len(items))
|
|
lock.Unlock()
|
|
}, WithBulkTasks(10), WithBulkInterval(time.Minute))
|
|
|
|
for i := 0; i < 50; i++ {
|
|
exeutor.Add(1)
|
|
time.Sleep(time.Millisecond)
|
|
}
|
|
|
|
lock.Lock()
|
|
assert.True(t, len(values) > 0)
|
|
// ignore last value
|
|
for i := 0; i < len(values); i++ {
|
|
assert.Equal(t, 10, values[i])
|
|
}
|
|
lock.Unlock()
|
|
}
|
|
|
|
func TestBulkExecutorFlushInterval(t *testing.T) {
|
|
const (
|
|
caches = 10
|
|
size = 5
|
|
)
|
|
var wait sync.WaitGroup
|
|
|
|
wait.Add(1)
|
|
exeutor := NewBulkExecutor(func(items []interface{}) {
|
|
assert.Equal(t, size, len(items))
|
|
wait.Done()
|
|
}, WithBulkTasks(caches), WithBulkInterval(time.Millisecond*100))
|
|
|
|
for i := 0; i < size; i++ {
|
|
exeutor.Add(1)
|
|
}
|
|
|
|
wait.Wait()
|
|
}
|
|
|
|
func TestBulkExecutorEmpty(t *testing.T) {
|
|
NewBulkExecutor(func(items []interface{}) {
|
|
assert.Fail(t, "should not called")
|
|
}, WithBulkTasks(10), WithBulkInterval(time.Millisecond))
|
|
time.Sleep(time.Millisecond * 100)
|
|
}
|
|
|
|
func TestBulkExecutorFlush(t *testing.T) {
|
|
const (
|
|
caches = 10
|
|
tasks = 5
|
|
)
|
|
|
|
var wait sync.WaitGroup
|
|
wait.Add(1)
|
|
be := NewBulkExecutor(func(items []interface{}) {
|
|
assert.Equal(t, tasks, len(items))
|
|
wait.Done()
|
|
}, WithBulkTasks(caches), WithBulkInterval(time.Minute))
|
|
for i := 0; i < tasks; i++ {
|
|
be.Add(1)
|
|
}
|
|
be.Flush()
|
|
wait.Wait()
|
|
}
|
|
|
|
func TestBuldExecutorFlushSlowTasks(t *testing.T) {
|
|
const total = 1500
|
|
lock := new(sync.Mutex)
|
|
result := make([]interface{}, 0, 10000)
|
|
exec := NewBulkExecutor(func(tasks []interface{}) {
|
|
time.Sleep(time.Millisecond * 100)
|
|
lock.Lock()
|
|
defer lock.Unlock()
|
|
for _, i := range tasks {
|
|
result = append(result, i)
|
|
}
|
|
}, WithBulkTasks(1000))
|
|
for i := 0; i < total; i++ {
|
|
assert.Nil(t, exec.Add(i))
|
|
}
|
|
|
|
exec.Flush()
|
|
exec.Wait()
|
|
assert.Equal(t, total, len(result))
|
|
}
|
|
|
|
func BenchmarkBulkExecutor(b *testing.B) {
|
|
b.ReportAllocs()
|
|
|
|
be := NewBulkExecutor(func(tasks []interface{}) {
|
|
time.Sleep(time.Millisecond * time.Duration(len(tasks)))
|
|
})
|
|
for i := 0; i < b.N; i++ {
|
|
time.Sleep(time.Microsecond * 200)
|
|
be.Add(1)
|
|
}
|
|
be.Flush()
|
|
}
|