feat(ats): add ODP integration. (#355)

## Summary
This PR adds a support for Optimizely Data Platform (ODP) integration to Full Stack. With this extension, clients may not need to pre-determine and include user segments in attributes. SDK can fetch user segments from the ODP server for the current user. 

- Add a new public API to OptimizelyUserContext (fetchQualifiedSegments).
- Add a new public API to OptimizelyClient (SendOdpEvent).

## Test plan
- Tests for OptimizelyUserContext new APIs.
- Tests for OptimizelyClient new APIs.
- Tests for odpManager.

## Issues
- FSSDK-8516

Author: yasirfolio3

pkg/client/client.go

@@ -33,6 +33,9 @@ import (
 	"github.com/optimizely/go-sdk/pkg/event"
 	"github.com/optimizely/go-sdk/pkg/logging"
 	"github.com/optimizely/go-sdk/pkg/notification"
+	"github.com/optimizely/go-sdk/pkg/odp"
+	pkgOdpSegment "github.com/optimizely/go-sdk/pkg/odp/segment"
+	pkgOdpUtils "github.com/optimizely/go-sdk/pkg/odp/utils"
 	"github.com/optimizely/go-sdk/pkg/optimizelyjson"
 	"github.com/optimizely/go-sdk/pkg/utils"
 
@@ -44,6 +47,7 @@ type OptimizelyClient struct {
 	ConfigManager        config.ProjectConfigManager
 	DecisionService      decision.Service
 	EventProcessor       event.Processor
+	OdpManager           odp.Manager
 	notificationCenter   notification.Center
 	execGroup            *utils.ExecGroup
 	logger               logging.OptimizelyLogProducer
@@ -53,6 +57,10 @@ type OptimizelyClient struct {
 // CreateUserContext creates a context of the user for which decision APIs will be called.
 // A user context will be created successfully even when the SDK is not fully configured yet.
 func (o *OptimizelyClient) CreateUserContext(userID string, attributes map[string]interface{}) OptimizelyUserContext {
+	if o.OdpManager != nil {
+		// Identify user to odp server
+		o.OdpManager.IdentifyUser(userID)
+	}
 	// Passing qualified segments as nil initially since they will be fetched later
 	return newOptimizelyUserContext(o, userID, attributes, nil, nil)
 }
@@ -234,6 +242,77 @@ func (o *OptimizelyClient) decideAll(userContext OptimizelyUserContext, options
 	return o.decideForKeys(userContext, allFlagKeys, options)
 }
 
+// fetchQualifiedSegments fetches all qualified segments for the user context.
+// request is performed asynchronously only when callback is provided
+func (o *OptimizelyClient) fetchQualifiedSegments(userContext *OptimizelyUserContext, options []pkgOdpSegment.OptimizelySegmentOption, callback func(success bool)) {
+	var err error
+	defer func() {
+		if r := recover(); r != nil {
+			switch t := r.(type) {
+			case error:
+				err = t
+			case string:
+				err = errors.New(t)
+			default:
+				err = errors.New("unexpected error")
+			}
+			o.logger.Error("fetchQualifiedSegments call, optimizely SDK is panicking with the error:", err)
+			o.logger.Debug(string(debug.Stack()))
+		}
+	}()
+
+	// on failure, qualifiedSegments should be reset if a previous value exists.
+	userContext.SetQualifiedSegments(nil)
+
+	if _, err = o.getProjectConfig(); err != nil {
+		o.logger.Error("fetchQualifiedSegments failed with error:", decide.GetDecideError(decide.SDKNotReady))
+		if callback != nil {
+			callback(false)
+		}
+		return
+	}
+
+	qualifiedSegments, segmentsError := o.OdpManager.FetchQualifiedSegments(userContext.GetUserID(), options)
+	success := segmentsError == nil
+
+	if success {
+		userContext.SetQualifiedSegments(qualifiedSegments)
+	} else {
+		o.logger.Error("fetchQualifiedSegments failed with error:", segmentsError)
+	}
+
+	if callback != nil {
+		callback(success)
+	}
+}
+
+// SendOdpEvent sends an event to the ODP server.
+func (o *OptimizelyClient) SendOdpEvent(eventType, action string, identifiers map[string]string, data map[string]interface{}) bool {
+
+	var err error
+	defer func() {
+		if r := recover(); r != nil {
+			switch t := r.(type) {
+			case error:
+				err = t
+			case string:
+				err = errors.New(t)
+			default:
+				err = errors.New("unexpected error")
+			}
+			errorMessage := fmt.Sprintf("SendOdpEvent call, optimizely SDK is panicking with the error:")
+			o.logger.Error(errorMessage, err)
+			o.logger.Debug(string(debug.Stack()))
+		}
+	}()
+
+	// the event type (default = "fullstack").
+	if eventType == "" {
+		eventType = pkgOdpUtils.OdpEventType
+	}
+	return o.OdpManager.SendOdpEvent(eventType, action, identifiers, data)
+}
+
 // Activate returns the key of the variation the user is bucketed into and queues up an impression event to be sent to
 // the Optimizely log endpoint for results processing.
 func (o *OptimizelyClient) Activate(experimentKey string, userContext entities.UserContext) (result string, err error) {

pkg/client/client_test.go

@@ -1,11 +1,11 @@
 /****************************************************************************
- * Copyright 2019-2020, Optimizely, Inc. and contributors                   *
+ * Copyright 2019-2020,2022 Optimizely, Inc. and contributors               *
  *                                                                          *
  * Licensed under the Apache License, Version 2.0 (the "License");          *
  * you may not use this file except in compliance with the License.         *
  * You may obtain a copy of the License at                                  *
  *                                                                          *
- *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *    https://www.apache.org/licenses/LICENSE-2.0                           *
  *                                                                          *
  * Unless required by applicable law or agreed to in writing, software      *
  * distributed under the License is distributed on an "AS IS" BASIS,        *
@@ -23,6 +23,7 @@ import (
 	"strconv"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/optimizely/go-sdk/pkg/config"
 	"github.com/optimizely/go-sdk/pkg/decide"
@@ -31,6 +32,9 @@ import (
 	"github.com/optimizely/go-sdk/pkg/event"
 	"github.com/optimizely/go-sdk/pkg/logging"
 	"github.com/optimizely/go-sdk/pkg/notification"
+	"github.com/optimizely/go-sdk/pkg/odp"
+	"github.com/optimizely/go-sdk/pkg/odp/segment"
+	pkgOdpUtils "github.com/optimizely/go-sdk/pkg/odp/utils"
 	"github.com/optimizely/go-sdk/pkg/utils"
 
 	"github.com/stretchr/testify/assert"
@@ -172,6 +176,84 @@ func (TestConfig) GetClientVersion() string {
 	return "1.0.0"
 }
 
+type MockODPManager struct {
+	odp.Manager
+	mock.Mock
+}
+
+func (m *MockODPManager) FetchQualifiedSegments(userID string, options []segment.OptimizelySegmentOption) (segments []string, err error) {
+	args := m.Called(userID, options)
+	if segArray, ok := args.Get(0).([]string); ok {
+		segments = segArray
+	}
+	return segments, args.Error(1)
+}
+
+func (m *MockODPManager) IdentifyUser(userID string) {
+	m.Called(userID)
+}
+
+func (m *MockODPManager) SendOdpEvent(eventType, action string, identifiers map[string]string, data map[string]interface{}) bool {
+	return m.Called(eventType, action, identifiers, data).Get(0).(bool)
+}
+
+func (m *MockODPManager) Update(apiKey, apiHost string, segmentsToCheck []string) {
+	m.Called(apiKey, apiHost, segmentsToCheck)
+}
+
+func TestSendODPEventWhenODPDisabled(t *testing.T) {
+	factory := OptimizelyFactory{SDKKey: "1212"}
+	var segmentsCacheSize = 1
+	var segmentsCacheTimeout = 1 * time.Second
+	var disableOdp = true
+	optimizelyClient, err := factory.Client(WithSegmentsCacheSize(segmentsCacheSize), WithSegmentsCacheTimeout(segmentsCacheTimeout), WithOdpDisabled(disableOdp))
+	assert.NoError(t, err)
+	success := optimizelyClient.SendOdpEvent("123", "456", map[string]string{
+		"abc": "123",
+	}, map[string]interface{}{
+		"abc":                 nil,
+		"idempotence_id":      234,
+		"data_source_type":    "456",
+		"data_source":         true,
+		"data_source_version": 6.78,
+	})
+	assert.False(t, success)
+}
+
+func TestSendODPEventEmptyType(t *testing.T) {
+	eventType := pkgOdpUtils.OdpEventType
+	action := "456"
+	identifiers := map[string]string{
+		"abc": "123",
+	}
+	data := map[string]interface{}{
+		"abc":                 nil,
+		"idempotence_id":      234,
+		"data_source_type":    "456",
+		"data_source":         true,
+		"data_source_version": 6.78,
+	}
+	mockOdpManager := &MockODPManager{}
+	mockOdpManager.On("SendOdpEvent", eventType, action, identifiers, data).Return(true)
+	optimizelyClient := OptimizelyClient{
+		OdpManager: mockOdpManager,
+	}
+	success := optimizelyClient.SendOdpEvent("", action, identifiers, data)
+	assert.True(t, success)
+	mockOdpManager.AssertExpectations(t)
+}
+
+func TestSendODPEvent(t *testing.T) {
+	mockOdpManager := &MockODPManager{}
+	mockOdpManager.On("SendOdpEvent", "123", "", mock.Anything, mock.Anything).Return(true)
+	optimizelyClient := OptimizelyClient{
+		OdpManager: mockOdpManager,
+	}
+	success := optimizelyClient.SendOdpEvent("123", "", nil, nil)
+	assert.True(t, success)
+	mockOdpManager.AssertExpectations(t)
+}
+
 func TestTrack(t *testing.T) {
 	mockProcessor := new(MockProcessor)
 	mockDecisionService := new(MockDecisionService)
@@ -2459,6 +2541,35 @@ func TestCreateUserContext(t *testing.T) {
 	assert.Equal(t, userAttributes, optimizelyUserContext.GetUserAttributes())
 }
 
+func TestCreateUserContextIdentifiesUser(t *testing.T) {
+	userID := "1212121"
+	userAttributes := map[string]interface{}{"key": 1212}
+	factory := OptimizelyFactory{SDKKey: "1212"}
+	mockOdpManager := &MockODPManager{}
+	mockOdpManager.On("IdentifyUser", userID)
+	client, err := factory.Client(WithOdpManager(mockOdpManager))
+	assert.NoError(t, err)
+	optimizelyUserContext := client.CreateUserContext(userID, userAttributes)
+	mockOdpManager.AssertExpectations(t)
+	assert.NotNil(t, optimizelyUserContext.optimizely.OdpManager)
+	assert.Equal(t, userID, optimizelyUserContext.GetUserID())
+	assert.Equal(t, userAttributes, optimizelyUserContext.GetUserAttributes())
+}
+
+func TestCreateUserContextWithNilODPManager(t *testing.T) {
+	userID := "1212121"
+	userAttributes := map[string]interface{}{"key": 1212}
+	factory := OptimizelyFactory{SDKKey: "1212"}
+	mockOdpManager := &MockODPManager{}
+	client, err := factory.Client(WithOdpManager(mockOdpManager))
+	assert.NoError(t, err)
+	client.OdpManager = nil
+	optimizelyUserContext := client.CreateUserContext(userID, userAttributes)
+	mockOdpManager.AssertNotCalled(t, "IdentifyUser", userID)
+	assert.Equal(t, userID, optimizelyUserContext.GetUserID())
+	assert.Equal(t, userAttributes, optimizelyUserContext.GetUserAttributes())
+}
+
 func TestChangingAttributesDoesntEffectUserContext(t *testing.T) {
 	client := OptimizelyClient{}
 	userID := "1"