added test for MP Init method with mock providers that have Init methods

Signed-off-by: bbland1 <[email protected]>

Author: bbland1

.release-please-manifest.json

@@ -16,5 +16,5 @@
     "providers/prefab": "0.0.2",
     "tests/flagd": "1.4.1",
     "providers/go-feature-flag-in-process": "0.1.0",
-    "providers/multi-provider": "0.0.1"
+    "providers/multi-provider": "0.0.2"
 }

providers/multi-provider/pkg/providers_test.go

@@ -2,13 +2,57 @@ package multiprovider
 
 import (
 	"testing"
+	"time"
 
 	"github.com/open-feature/go-sdk/openfeature"
 	"github.com/open-feature/go-sdk/openfeature/hooks"
 	"github.com/open-feature/go-sdk/openfeature/memprovider"
 	oft "github.com/open-feature/go-sdk/openfeature/testing"
 )
 
+// MockProvider utilizes openfeature's TestProvider to add testable Init & Shutdown methods to test the MultiProvider functionality
+type MockProvider struct {
+	oft.TestProvider
+	InitCount *int
+}
+
+func (m *MockProvider) Init(evalCtx openfeature.EvaluationContext) error {
+	*m.InitCount += 1
+	return nil
+}
+
+func (m *MockProvider) Shutdown() {
+}
+
+func NewMockProvider(initCount *int) *MockProvider {
+	return &MockProvider{
+		TestProvider: oft.NewTestProvider(),
+		InitCount: initCount,
+	}
+}
+
+// MockProviderDelay utilizes openfeature's TestProvider to add testable Init & Shutdown methods to test the MultiProvider functionality with a small delay making sure the the go routines properly wait.
+type MockProviderDelay struct {
+	oft.TestProvider
+	InitCount *int
+}
+
+func (m *MockProviderDelay) Init(evalCtx openfeature.EvaluationContext) error {
+	time.Sleep(1 * time.Millisecond)
+	*m.InitCount += 1
+	return nil
+}
+
+func (m *MockProviderDelay) Shutdown() {
+}
+
+func NewMockProviderDelay(initCount *int) *MockProviderDelay {
+	return &MockProviderDelay{
+		TestProvider: oft.NewTestProvider(),
+		InitCount: initCount,
+	}
+}
+
 func TestMultiProvider_ProvidersMethod(t *testing.T) {
 	testProvider1 := oft.NewTestProvider()
 	testProvider2 := oft.NewTestProvider()
@@ -123,7 +167,7 @@ func TestMultiProvider_ProviderByNameMethod(t *testing.T) {
 	}
 
 	providers := mp.ProvidersByName()
-	
+
 	if len(providers) != 2 {
 		t.Errorf("Expected there to be '2' providers as passed but got: '%d'", len(providers))
 	}
@@ -177,31 +221,54 @@ func TestMultiProvider_MetaData(t *testing.T) {
 	}
 }
 
-// func TestMultiProvider_Init(t *testing.T) {
-// 	testProvider1 := oft.NewTestProvider()
-// 	testProvider2 := oft.NewTestProvider()
-
-// 	defaultLogger, err := hooks.NewLoggingHook(false)
-// 	if err != nil {
-// 		t.Errorf("Issue setting up logger,'%s'", err)
-// 	}
-
-// 	mp, err := NewMultiProvider([]UniqueNameProvider{
-// 		{
-// 			Provider:   testProvider1,
-// 			UniqueName: "provider1",
-// 		}, {
-// 			Provider:   testProvider2,
-// 			UniqueName: "provider2",
-// 		},
-// 	}, "test", defaultLogger)
-
-// 	if err != nil {
-// 		t.Errorf("Expected the multiprovider to successfully make an instance, '%s'", err)
-// 	}
-
-// 	mp.Init()
-// }
+func TestMultiProvider_Init(t *testing.T) {
+	initializations := 0
+
+	testProvider1 := NewMockProvider(&initializations)
+	testProvider2 := oft.NewTestProvider()
+	testProvider3 := NewMockProviderDelay(&initializations)
+
+	defaultLogger, err := hooks.NewLoggingHook(false)
+	if err != nil {
+		t.Errorf("Issue setting up logger,'%s'", err)
+	}
+
+	mp, err := NewMultiProvider([]UniqueNameProvider{
+		{
+			Provider:   testProvider1,
+			UniqueName: "provider1",
+		}, {
+			Provider:   testProvider2,
+			UniqueName: "provider2",
+		},{
+			Provider:   testProvider3,
+			UniqueName: "provider3",
+		},
+	}, "test", defaultLogger)
+
+	if err != nil {
+		t.Errorf("Expected the multiprovider to successfully make an instance, '%s'", err)
+	}
+
+	attributes := map[string]interface{}{
+		"foo": "bar",
+	}
+	evalCtx := openfeature.NewTargetlessEvaluationContext(attributes)
+
+	err = mp.Init(evalCtx)
+	if err != nil {
+		t.Errorf("Expected the initialization process to be successful, got error: '%s'", err)
+	}
+
+	if initializations == 0 {
+		t.Errorf("Expected there to be initializations, but none were ran.")
+	}
+
+	if initializations != 2 {
+		t.Errorf("Expected there to be '2' init steps ran, but got: '%d'.", initializations)
+	}
+
+}
 
 func TestNewMultiProvider_ProviderUniqueNames(t *testing.T) {
 	testProvider1 := memprovider.NewInMemoryProvider(map[string]memprovider.InMemoryFlag{