MOD: use fake meta manager and custom update interval to fast up test…

… cases

push/manager.go

@@ -3,6 +3,7 @@ package push
 import (
 	"errors"
 	"sync"
+	"time"
 
 	"github.com/go-redis/redis"
 	"github.com/sirupsen/logrus"
@@ -17,12 +18,13 @@ type Manager struct {
 	logger  *logrus.Logger
 }
 
-func NewManger(redisCli *redis.Client, logger *logrus.Logger) (*Manager, error) {
+func NewManger(redisCli *redis.Client, updateInterval time.Duration, logger *logrus.Logger) (*Manager, error) {
 	var err error
 	manager := new(Manager)
 	manager.logger = logger
 	manager.MetaManager, err = newMetaManager(
 		redisCli,
+		updateInterval,
 		logger,
 		manager.onCreated,
 		manager.onUpdated,
@@ -102,17 +104,27 @@ func (m *Manager) onDeleted(pool, ns, queue string) {
 	}
 }
 
+// SetCallbacks used to set custom callback when meta was changed.
+// e.g. we want to use empty callback function to fasten test cases
+func (m *Manager) SetCallbacks(onCreated onCreatedFunc,
+	onUpdated onUpdatedFunc,
+	onDeleted onDeletedFunc) {
+	m.MetaManager.onCreated = onCreated
+	m.MetaManager.onUpdated = onUpdated
+	m.MetaManager.onDeleted = onDeleted
+}
+
 var _manager *Manager
 
-func Setup(conf *config.Config, logger *logrus.Logger) error {
+func Setup(conf *config.Config, updateInterval time.Duration, logger *logrus.Logger) error {
 	var err error
 	redisConf := conf.AdminRedis
 	cli := helper.NewRedisClient(&redisConf, nil)
 	if cli.Ping().Err() != nil {
 		return errors.New("can not connect to admin redis")
 	}
 	setupMetrics()
-	_manager, err = NewManger(cli, logger)
+	_manager, err = NewManger(cli, updateInterval, logger)
 	return err
 }
 

push/meta.go

@@ -37,6 +37,7 @@ type MetaManager struct {
 	metas              map[string]*Meta
 	logger             *logrus.Logger
 	latestMetasVersion int64
+	updateInterval     time.Duration
 
 	// callback functions
 	onCreated onCreatedFunc
@@ -48,6 +49,7 @@ type MetaManager struct {
 
 func newMetaManager(
 	redisCli *redis.Client,
+	updateInterval time.Duration,
 	logger *logrus.Logger,
 	onCreated onCreatedFunc,
 	onUpdated onUpdatedFunc,
@@ -58,6 +60,7 @@ func newMetaManager(
 	}
 	mm := &MetaManager{
 		redisCli:           redisCli,
+		updateInterval:     updateInterval,
 		logger:             logger,
 		onCreated:          onCreated,
 		onUpdated:          onUpdated,
@@ -146,7 +149,7 @@ func (mm *MetaManager) asyncLoop() {
 			}).Error("Panic in meta manager")
 		}
 	}()
-	ticker := time.NewTicker(3 * time.Second)
+	ticker := time.NewTicker(mm.updateInterval)
 	mm.updateMetas()
 	for {
 		select {

push/meta_test.go

@@ -5,22 +5,29 @@ import (
 	"time"
 )
 
+func TestSetup(t *testing.T) {
+	GetManager().SetCallbacks(
+		func(pool, ns, queue string, meta *Meta) {},
+		func(pool, ns, queue string, newMeta *Meta) {},
+		func(pool, ns, queue string) {})
+}
+
 func TestMetaManager_Dump(t *testing.T) {
 	testMeta := &Meta{
 		Endpoint: "test-endpoint",
 		Workers:  5,
 		Timeout:  5,
 	}
-	err := _manager.MetaManager.Create("default", "test-ns-dump1", "test-queue1", testMeta)
+	err := _manager.Create("default", "test-ns-dump1", "test-queue1", testMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	err = _manager.MetaManager.Create("default", "test-ns-dump2", "test-queue2", testMeta)
+	err = _manager.Create("default", "test-ns-dump2", "test-queue2", testMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	time.Sleep(4 * time.Second)
-	metaMap := _manager.MetaManager.Dump()
+	time.Sleep(500 * time.Millisecond)
+	metaMap := _manager.Dump()
 	if len(metaMap) != 1 {
 		t.Fatalf("expect dump return 1 metaMaps, but got %d", len(metaMap))
 	}
@@ -51,19 +58,19 @@ func TestMetaManager_CreateAndGet(t *testing.T) {
 		Workers:  5,
 		Timeout:  5,
 	}
-	err := _manager.MetaManager.Create("default", "test-ns", "test-queue-get", testMeta)
+	err := _manager.Create("default", "test-ns", "test-queue-get", testMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	meta, err := _manager.MetaManager.GetFromRemote("default", "test-ns", "test-queue-get")
+	meta, err := _manager.GetFromRemote("default", "test-ns", "test-queue-get")
 	if err != nil {
 		t.Fatalf("expect metaManager get from remote return nil, but got %v", err)
 	}
 	if meta.Timeout != testMeta.Timeout || meta.Workers != testMeta.Workers || meta.Endpoint != testMeta.Endpoint {
 		t.Fatalf("expect metaManager get from remote meta equel testMeta")
 	}
-	time.Sleep(4 * time.Second)
-	meta = _manager.MetaManager.Get("default", "test-ns", "test-queue-get")
+	time.Sleep(500 * time.Millisecond)
+	meta = _manager.Get("default", "test-ns", "test-queue-get")
 	if meta == nil {
 		t.Fatalf("expect metaManager get return meta, but got nil")
 	}
@@ -78,30 +85,30 @@ func TestMetaManager_Update(t *testing.T) {
 		Workers:  5,
 		Timeout:  5,
 	}
-	err := _manager.MetaManager.Create("default", "test-ns", "test-queue-update", testMeta)
+	err := _manager.Create("default", "test-ns", "test-queue-update", testMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	time.Sleep(4 * time.Second)
+	time.Sleep(500 * time.Millisecond)
 	newMeta := &Meta{
 		Endpoint: "test-endpoint-new",
 		Workers:  10,
 		Timeout:  10,
 	}
-	err = _manager.MetaManager.Update("default", "test-ns", "test-queue-update", newMeta)
+	err = _manager.Update("default", "test-ns", "test-queue-update", newMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	meta, err := _manager.MetaManager.GetFromRemote("default", "test-ns", "test-queue-update")
+	meta, err := _manager.GetFromRemote("default", "test-ns", "test-queue-update")
 	if err != nil {
 		t.Fatalf("expect metaManager get from remote return nil, but got %v", err)
 	}
 	if meta.Timeout != newMeta.Timeout || meta.Workers != newMeta.Workers || meta.Endpoint != newMeta.Endpoint {
 		t.Fatalf("expect metaManager get from remote meta equel newMeta")
 	}
 	// wait for meta update and pusher restart
-	time.Sleep(6 * time.Second)
-	meta = _manager.MetaManager.Get("default", "test-ns", "test-queue-update")
+	time.Sleep(500 * time.Millisecond)
+	meta = _manager.Get("default", "test-ns", "test-queue-update")
 	if meta == nil {
 		t.Fatalf("expect metaManager get return meta, but got nil")
 	}
@@ -116,12 +123,12 @@ func TestMetaManager_Delete(t *testing.T) {
 		Workers:  5,
 		Timeout:  5,
 	}
-	err := _manager.MetaManager.Create("default", "test-ns", "test-queue-delete", testMeta)
+	err := _manager.Create("default", "test-ns", "test-queue-delete", testMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	time.Sleep(6 * time.Second)
-	meta := _manager.MetaManager.Get("default", "test-ns", "test-queue-delete")
+	time.Sleep(500 * time.Millisecond)
+	meta := _manager.Get("default", "test-ns", "test-queue-delete")
 	if meta == nil {
 		t.Fatalf("expect metaManager get return meta, but got nil")
 	}
@@ -133,16 +140,16 @@ func TestMetaManager_Delete(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expect metaManager delete return nil, but got %v", err)
 	}
-	meta, err = _manager.MetaManager.GetFromRemote("default", "test-ns", "test-queue-delete")
+	meta, err = _manager.GetFromRemote("default", "test-ns", "test-queue-delete")
 	if err != nil {
 		t.Fatalf("expect metaManager get from remote return nil, but got %v", err)
 	}
 	if meta != nil {
 		t.Fatalf("expect metaManager get from remote meta equel nil")
 	}
 	// wait for meta update and pusher stop
-	time.Sleep(12 * time.Second)
-	meta = _manager.MetaManager.Get("default", "test-ns", "test-queue-delete")
+	time.Sleep(500 * time.Millisecond)
+	meta = _manager.Get("default", "test-ns", "test-queue-delete")
 	if meta != nil {
 		t.Fatalf("expect metaManager get return nil")
 	}
@@ -154,16 +161,16 @@ func TestMetaManager_ListPusherByNamespace(t *testing.T) {
 		Workers:  5,
 		Timeout:  5,
 	}
-	err := _manager.MetaManager.Create("default", "test-ns-list", "test-queue1", testMeta)
+	err := _manager.Create("default", "test-ns-list", "test-queue1", testMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	err = _manager.MetaManager.Create("default", "test-ns-list", "test-queue2", testMeta)
+	err = _manager.Create("default", "test-ns-list", "test-queue2", testMeta)
 	if err != nil {
 		t.Fatalf("expect metaManager create return nil, but got %v", err)
 	}
-	time.Sleep(6 * time.Second)
-	metaMap := _manager.MetaManager.ListPusherByNamespace("default", "test-ns-list")
+	time.Sleep(500 * time.Millisecond)
+	metaMap := _manager.ListPusherByNamespace("default", "test-ns-list")
 	if len(metaMap) != 2 {
 		t.Fatalf("expect list pusher by namespace return 2 meta, but got %d", len(metaMap))
 	}
@@ -177,3 +184,7 @@ func TestMetaManager_ListPusherByNamespace(t *testing.T) {
 	}
 
 }
+
+func TestShutdown(t *testing.T) {
+	GetManager().SetCallbacks(_manager.onCreated, _manager.onUpdated, _manager.onDeleted)
+}

push/pusher_test.go

@@ -37,7 +37,7 @@ func TestPusher(t *testing.T) {
 	stopServer := make(chan struct{})
 	sentJobs := make(map[string]bool)
 	go func() {
-		tick := time.NewTicker(1 * time.Second)
+		tick := time.NewTicker(time.Second)
 		for {
 			select {
 			case <-tick.C:

push/setup_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/bitleak/lmstfy/helper"
 
@@ -51,7 +52,7 @@ func setup() {
 		panic(fmt.Sprintf("Failed to flush db: %s", err))
 	}
 
-	if err := Setup(CONF, logger); err != nil {
+	if err := Setup(CONF, 100*time.Millisecond, logger); err != nil {
 		panic(fmt.Sprintf("Failed to setup push engine: %s", err))
 	}
 }

server/handlers/pusher_test.go

@@ -2,14 +2,22 @@ package handlers_test
 
 import (
 	"fmt"
-	"github.com/bitleak/lmstfy/push"
-	"github.com/bitleak/lmstfy/server/handlers"
 	"net/http"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/bitleak/lmstfy/push"
+	"github.com/bitleak/lmstfy/server/handlers"
 )
 
+func TestSetup(t *testing.T) {
+	push.GetManager().SetCallbacks(
+		func(pool, ns, queue string, meta *push.Meta) {},
+		func(pool, ns, queue string, newMeta *push.Meta) {},
+		func(pool, ns, queue string) {})
+}
+
 func TestCreateQueuePusher(t *testing.T) {
 	limitStr := "{\"timeout\": 3, \"workers\": 5, \"endpoint\":\"http://test-endpoint\"}"
 	targetUrl := fmt.Sprintf("http://localhost/pusher/ns-pusher/queue-pusher")
@@ -25,7 +33,7 @@ func TestCreateQueuePusher(t *testing.T) {
 		t.Logf(resp.Body.String())
 		t.Fatal("Failed to create new queue pusher")
 	}
-	time.Sleep(6 * time.Second)
+	time.Sleep(500 * time.Millisecond)
 	meta := push.GetManager().Get("default", "ns-pusher", "queue-pusher")
 	if meta == nil || meta.Endpoint != "http://test-endpoint" || meta.Timeout != 3 || meta.Workers != 5 {
 		t.Fatal("Mismatch meta in create")
@@ -92,7 +100,7 @@ func TestUpdateQueuePusher(t *testing.T) {
 		t.Logf(resp.Body.String())
 		t.Fatal("Failed to update queue pusher")
 	}
-	time.Sleep(15 * time.Second)
+	time.Sleep(500 * time.Millisecond)
 	meta := push.GetManager().Get("default", "ns-pusher", "queue-pusher")
 	if meta == nil || meta.Endpoint != "http://test-enpoint-new" || meta.Timeout != 1 || meta.Workers != 3 {
 		t.Fatal("Mismatch meta in update queue pusher")
@@ -112,7 +120,7 @@ func TestDeleteQueuePusher(t *testing.T) {
 		t.Logf(resp.Body.String())
 		t.Fatal("Failed to list namespace pusher")
 	}
-	time.Sleep(15 * time.Second)
+	time.Sleep(500 * time.Millisecond)
 	meta := push.GetManager().Get("default", "ns-pusher", "queue-pusher")
 	if meta != nil {
 		t.Fatal("Mismatch meta in delete queue pusher")

server/handlers/setup_test.go

@@ -6,6 +6,7 @@ import (
 	"net/http/httptest"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/bitleak/lmstfy/auth"
 	"github.com/bitleak/lmstfy/config"
@@ -83,7 +84,7 @@ func setup() {
 	if err := throttler.Setup(&CONF.AdminRedis, logger); err != nil {
 		panic(fmt.Sprintf("Failed to setup throttler module: %s", err))
 	}
-	if err := push.Setup(CONF, logger); err != nil {
+	if err := push.Setup(CONF, 100*time.Millisecond, logger); err != nil {
 		panic(fmt.Sprintf("Failed to setup push module: %s", err))
 	}
 	handlers.SetupParamDefaults(CONF)

server/main.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
+	"time"
 
 	"github.com/bitleak/lmstfy/auth"
 	"github.com/bitleak/lmstfy/config"
@@ -198,7 +199,7 @@ func main() {
 	if err := auth.Setup(conf); err != nil {
 		panic(fmt.Sprintf("Failed to setup auth module: %s", err))
 	}
-	if err := push.Setup(conf, errorLogger); err != nil {
+	if err := push.Setup(conf, 3*time.Second, errorLogger); err != nil {
 		panic(fmt.Sprintf("Failed to setup push module: %s", err))
 	}
 	if conf.EnableAccessLog {