(fix): update for tests to run 5 times faster (#145)

* update for tests to run 5 times faster

* fix broken test

* increase code coverage

* fix queue test

Author: thomaszurkan-optimizely

pkg/client/factory_test.go

@@ -111,7 +111,7 @@ func TestClientWithDecisionServiceAndEventProcessorInOptions(t *testing.T) {
 		MaxQueueSize:    100,
 		FlushInterval:   100,
 		Q:               event.NewInMemoryQueue(100),
-		EventDispatcher: &MockDispatcher{},
+		EventDispatcher: &MockDispatcher{Events:[]event.LogEvent{}},
 	}
 
 	optimizelyClient, err := factory.Client(WithConfigManager(configManager), WithDecisionService(decisionService), WithEventProcessor(processor))

pkg/event/chan_queue_test.go

@@ -33,7 +33,7 @@ func TestChanQueue_Add_Size_Remove(t *testing.T) {
 	q.Add(impression)
 	q.Add(conversion)
 
-	time.Sleep(2000 * time.Millisecond)
+	time.Sleep(100 * time.Millisecond)
 
 	items1 := q.Get(2)
 

pkg/event/dispatcher.go

@@ -29,7 +29,7 @@ import (
 
 const maxRetries = 3
 const defaultQueueSize = 1000
-const sleepTime = 5 * time.Second
+const sleepTime = 1 * time.Second
 
 var dispatcherLogger = logging.GetLogger("EventDispatcher")
 

pkg/event/factory_test.go

@@ -121,15 +121,17 @@ func TestCreateAndSendImpressionEvent(t *testing.T) {
 
 	impressionUserEvent := BuildTestImpressionEvent()
 
-	processor := NewBatchEventProcessor(WithBatchSize(10), WithQueueSize(100), WithFlushInterval(100))
+	processor := NewBatchEventProcessor(WithBatchSize(10), WithQueueSize(100),
+		WithFlushInterval(10),
+		WithEventDispatcher(&MockDispatcher{Events:NewInMemoryQueue(100)}))
 
 	processor.Start(utils.NewCancelableExecutionCtx())
 
 	processor.ProcessEvent(impressionUserEvent)
 
 	assert.Equal(t, 1, processor.EventsCount())
 
-	time.Sleep(2000 * time.Millisecond)
+	time.Sleep(100 * time.Millisecond)
 
 	assert.Equal(t, 0, processor.EventsCount())
 }
@@ -138,15 +140,16 @@ func TestCreateAndSendConversionEvent(t *testing.T) {
 
 	conversionUserEvent := BuildTestConversionEvent()
 
-	processor := NewBatchEventProcessor(WithFlushInterval(100))
+	processor := NewBatchEventProcessor(WithFlushInterval(10),
+		WithEventDispatcher(&MockDispatcher{Events:NewInMemoryQueue(100)}))
 
 	processor.Start(utils.NewCancelableExecutionCtx())
 
 	processor.ProcessEvent(conversionUserEvent)
 
 	assert.Equal(t, 1, processor.EventsCount())
 
-	time.Sleep(2000 * time.Millisecond)
+	time.Sleep(100 * time.Millisecond)
 
 	assert.Equal(t, 0, processor.EventsCount())
 }

pkg/event/processor_test.go

@@ -41,9 +41,15 @@ func (f *MockDispatcher) DispatchEvent(event LogEvent) (bool, error) {
 	return true, nil
 }
 
+func NewMockDispatcher(queueSize int, shouldFail bool) Dispatcher {
+	return &MockDispatcher{Events:NewInMemoryQueue(queueSize), ShouldFail:shouldFail}
+}
+
 func TestDefaultEventProcessor_ProcessImpression(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
-	processor := NewBatchEventProcessor(WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}), WithFlushInterval(100))
+	processor := NewBatchEventProcessor()
+	processor.EventDispatcher = nil
+	processor.Start(exeCtx)
 	processor.Start(exeCtx)
 
 	impression := BuildTestImpressionEvent()
@@ -61,7 +67,7 @@ func TestDefaultEventProcessor_ProcessImpression(t *testing.T) {
 
 func TestCustomEventProcessor_Create(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
-	processor := NewBatchEventProcessor(WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}), WithQueueSize(10), WithFlushInterval(100))
+	processor := NewBatchEventProcessor(WithEventDispatcher(NewMockDispatcher(100, false)), WithQueueSize(10), WithFlushInterval(100))
 	processor.Start(exeCtx)
 
 	impression := BuildTestImpressionEvent()
@@ -80,7 +86,7 @@ func TestCustomEventProcessor_Create(t *testing.T) {
 func TestDefaultEventProcessor_LogEventNotification(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
 	processor := NewBatchEventProcessor(WithFlushInterval(100), WithQueueSize(100),
-		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}),
+		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(NewMockDispatcher(100, false)),
 		WithSDKKey("fakeSDKKey"))
 
 	var logEvent LogEvent
@@ -108,13 +114,12 @@ func TestDefaultEventProcessor_LogEventNotification(t *testing.T) {
 	err := processor.RemoveOnEventDispatch(id)
 
 	assert.Nil(t, err)
-
 }
 
 func TestDefaultEventProcessor_ProcessBatch(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
 	processor := NewBatchEventProcessor(WithFlushInterval(100), WithQueueSize(100),
-		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}))
+		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(NewMockDispatcher(100, false)))
 	processor.Start(exeCtx)
 
 	impression := BuildTestImpressionEvent()
@@ -145,8 +150,8 @@ func TestDefaultEventProcessor_ProcessBatch(t *testing.T) {
 
 func TestDefaultEventProcessor_QSizeMet(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
-	processor := NewBatchEventProcessor(WithQueueSize(2), WithFlushInterval(100),
-		WithQueue(NewInMemoryQueue(2)), WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}))
+	processor := NewBatchEventProcessor(WithQueueSize(2), WithFlushInterval(1000),
+		WithQueue(NewInMemoryQueue(2)), WithEventDispatcher(NewMockDispatcher(100, false)))
 	processor.Start(exeCtx)
 
 	impression := BuildTestImpressionEvent()
@@ -217,7 +222,7 @@ func TestDefaultEventProcessor_FailedDispatch(t *testing.T) {
 func TestBatchEventProcessor_FlushesOnClose(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
 	processor := NewBatchEventProcessor(WithQueueSize(100), WithQueue(NewInMemoryQueue(100)),
-		WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}))
+		WithEventDispatcher(NewMockDispatcher(100, false)))
 	processor.Start(exeCtx)
 
 	impression := BuildTestImpressionEvent()
@@ -239,7 +244,7 @@ func TestBatchEventProcessor_FlushesOnClose(t *testing.T) {
 func TestDefaultEventProcessor_ProcessBatchRevisionMismatch(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
 	processor := NewBatchEventProcessor(WithQueueSize(100), WithFlushInterval(100),
-		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}))
+		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(NewMockDispatcher(100, false)))
 
 	processor.Start(exeCtx)
 
@@ -273,7 +278,7 @@ func TestDefaultEventProcessor_ProcessBatchRevisionMismatch(t *testing.T) {
 func TestDefaultEventProcessor_ProcessBatchProjectMismatch(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
 	processor := NewBatchEventProcessor(WithQueueSize(100), WithFlushInterval(100),
-		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}))
+		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(NewMockDispatcher(100, false)))
 
 	processor.Start(exeCtx)
 
@@ -326,7 +331,7 @@ func TestChanQueueEventProcessor_ProcessImpression(t *testing.T) {
 func TestChanQueueEventProcessor_ProcessBatch(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
 	processor := NewBatchEventProcessor(WithQueueSize(100), WithFlushInterval(100),
-		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(&MockDispatcher{Events: NewInMemoryQueue(100)}))
+		WithQueue(NewInMemoryQueue(100)), WithEventDispatcher(NewMockDispatcher(100, false)))
 	processor.Start(exeCtx)
 
 	impression := BuildTestImpressionEvent()