Suggested changes made.

pkg/client/client.go

@@ -46,7 +46,7 @@ type OptimizelyClient struct {
 	notificationCenter   notification.Center
 	execGroup            *utils.ExecGroup
 	logger               logging.OptimizelyLogProducer
-	defaultDecideoptions *decide.OptimizelyDecideOptions
+	defaultDecideOptions *decide.Options
 }
 
 // Decide API
@@ -57,7 +57,7 @@ func (o *OptimizelyClient) CreateUserContext(userID string, attributes map[strin
 	return newOptimizelyUserContext(o, userID, attributes)
 }
 
-func (o *OptimizelyClient) decide(userContext OptimizelyUserContext, key string, options *decide.OptimizelyDecideOptions) OptimizelyDecision {
+func (o *OptimizelyClient) decide(userContext OptimizelyUserContext, key string, options *decide.Options) OptimizelyDecision {
 	var err error
 	defer func() {
 		if r := recover(); r != nil {
@@ -135,7 +135,7 @@ func (o *OptimizelyClient) decide(userContext OptimizelyUserContext, key string,
 	return NewOptimizelyDecision(variationKey, ruleKey, key, flagEnabled, optimizelyJSON, userContext, reasonsToReport)
 }
 
-func (o *OptimizelyClient) decideForKeys(userContext OptimizelyUserContext, keys []string, options *decide.OptimizelyDecideOptions) map[string]OptimizelyDecision {
+func (o *OptimizelyClient) decideForKeys(userContext OptimizelyUserContext, keys []string, options *decide.Options) map[string]OptimizelyDecision {
 	var err error
 	defer func() {
 		if r := recover(); r != nil {
@@ -174,7 +174,7 @@ func (o *OptimizelyClient) decideForKeys(userContext OptimizelyUserContext, keys
 	return decisionMap
 }
 
-func (o *OptimizelyClient) decideAll(userContext OptimizelyUserContext, options *decide.OptimizelyDecideOptions) map[string]OptimizelyDecision {
+func (o *OptimizelyClient) decideAll(userContext OptimizelyUserContext, options *decide.Options) map[string]OptimizelyDecision {
 
 	var err error
 	defer func() {
@@ -809,7 +809,7 @@ func (o *OptimizelyClient) getFeatureDecision(featureKey, variableKey string, us
 	}
 
 	decisionContext.Variable = variable
-	options := &decide.OptimizelyDecideOptions{}
+	options := &decide.Options{}
 	featureDecision, err = o.DecisionService.GetFeatureDecision(decisionContext, userContext, options, decide.NewDecisionReasons(options))
 	if err != nil {
 		o.logger.Warning(fmt.Sprintf(`Received error while making a decision for feature "%s": %s`, featureKey, err))
@@ -840,7 +840,7 @@ func (o *OptimizelyClient) getExperimentDecision(experimentKey string, userConte
 		ProjectConfig: projectConfig,
 	}
 
-	options := &decide.OptimizelyDecideOptions{}
+	options := &decide.Options{}
 	experimentDecision, err = o.DecisionService.GetExperimentDecision(decisionContext, userContext, options, decide.NewDecisionReasons(options))
 	if err != nil {
 		o.logger.Warning(fmt.Sprintf(`Received error while making a decision for experiment "%s": %s`, experimentKey, err))
@@ -928,13 +928,13 @@ func (o *OptimizelyClient) getProjectConfig() (projectConfig config.ProjectConfi
 	return projectConfig, nil
 }
 
-func (o *OptimizelyClient) getAllOptions(options *decide.OptimizelyDecideOptions) decide.OptimizelyDecideOptions {
-	return decide.OptimizelyDecideOptions{
-		DisableDecisionEvent:     o.defaultDecideoptions.DisableDecisionEvent || options.DisableDecisionEvent,
-		EnabledFlagsOnly:         o.defaultDecideoptions.EnabledFlagsOnly || options.EnabledFlagsOnly,
-		ExcludeVariables:         o.defaultDecideoptions.ExcludeVariables || options.ExcludeVariables,
-		IgnoreUserProfileService: o.defaultDecideoptions.IgnoreUserProfileService || options.IgnoreUserProfileService,
-		IncludeReasons:           o.defaultDecideoptions.IncludeReasons || options.IncludeReasons,
+func (o *OptimizelyClient) getAllOptions(options *decide.Options) decide.Options {
+	return decide.Options{
+		DisableDecisionEvent:     o.defaultDecideOptions.DisableDecisionEvent || options.DisableDecisionEvent,
+		EnabledFlagsOnly:         o.defaultDecideOptions.EnabledFlagsOnly || options.EnabledFlagsOnly,
+		ExcludeVariables:         o.defaultDecideOptions.ExcludeVariables || options.ExcludeVariables,
+		IgnoreUserProfileService: o.defaultDecideOptions.IgnoreUserProfileService || options.IgnoreUserProfileService,
+		IncludeReasons:           o.defaultDecideOptions.IncludeReasons || options.IncludeReasons,
 	}
 }
 

pkg/client/factory.go

@@ -41,7 +41,7 @@ type OptimizelyFactory struct {
 	configManager        config.ProjectConfigManager
 	ctx                  context.Context
 	decisionService      decision.Service
-	defaultDecideoptions *decide.OptimizelyDecideOptions
+	defaultDecideOptions *decide.Options
 	eventDispatcher      event.Dispatcher
 	eventProcessor       event.Processor
 	userProfileService   decision.UserProfileService
@@ -77,16 +77,16 @@ func (f *OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClie
 		ctx = context.Background()
 	}
 
-	var decideOptions *decide.OptimizelyDecideOptions
-	if f.defaultDecideoptions != nil {
-		decideOptions = f.defaultDecideoptions
+	var decideOptions *decide.Options
+	if f.defaultDecideOptions != nil {
+		decideOptions = f.defaultDecideOptions
 	} else {
-		decideOptions = &decide.OptimizelyDecideOptions{}
+		decideOptions = &decide.Options{}
 	}
 
 	eg := utils.NewExecGroup(ctx, logging.GetLogger(f.SDKKey, "ExecGroup"))
 	appClient := &OptimizelyClient{
-		defaultDecideoptions: decideOptions,
+		defaultDecideOptions: decideOptions,
 		execGroup:            eg,
 		notificationCenter:   registry.GetNotificationCenter(f.SDKKey),
 		logger:               logging.GetLogger(f.SDKKey, "OptimizelyClient"),
@@ -180,9 +180,9 @@ func WithDecisionService(decisionService decision.Service) OptionFunc {
 }
 
 // WithDefaultDecideOptions sets default decide options on a client.
-func WithDefaultDecideOptions(decideOptions []decide.Options) OptionFunc {
+func WithDefaultDecideOptions(decideOptions []decide.OptimizelyDecideOptions) OptionFunc {
 	return func(f *OptimizelyFactory) {
-		f.defaultDecideoptions = convertDecideOptions(decideOptions)
+		f.defaultDecideOptions = convertDecideOptions(decideOptions)
 	}
 }
 
@@ -253,8 +253,8 @@ func (f *OptimizelyFactory) StaticClient() (optlyClient *OptimizelyClient, err e
 	return optlyClient, err
 }
 
-func convertDecideOptions(options []decide.Options) *decide.OptimizelyDecideOptions {
-	finalOptions := decide.OptimizelyDecideOptions{}
+func convertDecideOptions(options []decide.OptimizelyDecideOptions) *decide.Options {
+	finalOptions := decide.Options{}
 	for _, option := range options {
 		switch option {
 		case decide.DisableDecisionEvent:

pkg/client/factory_test.go

@@ -204,18 +204,18 @@ func TestClientWithDatafileAccessToken(t *testing.T) {
 }
 
 func TestClientWithDefaultDecideOptions(t *testing.T) {
-	decideOptions := []decide.Options{
+	decideOptions := []decide.OptimizelyDecideOptions{
 		decide.DisableDecisionEvent,
 		decide.EnabledFlagsOnly,
 	}
 	factory := OptimizelyFactory{SDKKey: "1212"}
 	optimizelyClient, err := factory.Client(WithDefaultDecideOptions(decideOptions))
 	assert.NoError(t, err)
-	assert.Equal(t, convertDecideOptions(decideOptions), optimizelyClient.defaultDecideoptions)
+	assert.Equal(t, convertDecideOptions(decideOptions), optimizelyClient.defaultDecideOptions)
 
 	// Verify that defaultDecideOptions are initialized as empty by default
 	factory = OptimizelyFactory{SDKKey: "1212"}
 	optimizelyClient, err = factory.Client()
 	assert.NoError(t, err)
-	assert.Equal(t, &decide.OptimizelyDecideOptions{}, optimizelyClient.defaultDecideoptions)
+	assert.Equal(t, &decide.Options{}, optimizelyClient.defaultDecideOptions)
 }

pkg/client/fixtures_test.go

@@ -117,12 +117,12 @@ type MockDecisionService struct {
 	mock.Mock
 }
 
-func (m *MockDecisionService) GetFeatureDecision(decisionContext decision.FeatureDecisionContext, userContext entities.UserContext, options *decide.OptimizelyDecideOptions, reasons decide.DecisionReasons) (decision.FeatureDecision, error) {
+func (m *MockDecisionService) GetFeatureDecision(decisionContext decision.FeatureDecisionContext, userContext entities.UserContext, options *decide.Options, reasons decide.DecisionReasons) (decision.FeatureDecision, error) {
 	args := m.Called(decisionContext, userContext, options, reasons)
 	return args.Get(0).(decision.FeatureDecision), args.Error(1)
 }
 
-func (m *MockDecisionService) GetExperimentDecision(decisionContext decision.ExperimentDecisionContext, userContext entities.UserContext, options *decide.OptimizelyDecideOptions, reasons decide.DecisionReasons) (decision.ExperimentDecision, error) {
+func (m *MockDecisionService) GetExperimentDecision(decisionContext decision.ExperimentDecisionContext, userContext entities.UserContext, options *decide.Options, reasons decide.DecisionReasons) (decision.ExperimentDecision, error) {
 	args := m.Called(decisionContext, userContext, options, reasons)
 	return args.Get(0).(decision.ExperimentDecision), args.Error(1)
 }
@@ -160,11 +160,11 @@ func (m *PanickingConfigManager) GetConfig() (config.ProjectConfig, error) {
 type PanickingDecisionService struct {
 }
 
-func (m *PanickingDecisionService) GetFeatureDecision(decisionContext decision.FeatureDecisionContext, userContext entities.UserContext, options *decide.OptimizelyDecideOptions, reasons decide.DecisionReasons) (decision.FeatureDecision, error) {
+func (m *PanickingDecisionService) GetFeatureDecision(decisionContext decision.FeatureDecisionContext, userContext entities.UserContext, options *decide.Options, reasons decide.DecisionReasons) (decision.FeatureDecision, error) {
 	panic("I'm panicking")
 }
 
-func (m *PanickingDecisionService) GetExperimentDecision(decisionContext decision.ExperimentDecisionContext, userContext entities.UserContext, options *decide.OptimizelyDecideOptions, reasons decide.DecisionReasons) (decision.ExperimentDecision, error) {
+func (m *PanickingDecisionService) GetExperimentDecision(decisionContext decision.ExperimentDecisionContext, userContext entities.UserContext, options *decide.Options, reasons decide.DecisionReasons) (decision.ExperimentDecision, error) {
 	panic("I'm panicking")
 }
 

pkg/client/optimizely_user_context.go

@@ -77,17 +77,17 @@ func (o *OptimizelyUserContext) SetAttribute(key string, value interface{}) {
 
 // Decide returns a decision result for a given flag key and a user context, which contains
 // all data required to deliver the flag or experiment.
-func (o *OptimizelyUserContext) Decide(key string, options []decide.Options) OptimizelyDecision {
+func (o *OptimizelyUserContext) Decide(key string, options []decide.OptimizelyDecideOptions) OptimizelyDecision {
 	return o.optimizely.decide(*o, key, convertDecideOptions(options))
 }
 
 // DecideAll returns a key-map of decision results for all active flag keys with options.
-func (o *OptimizelyUserContext) DecideAll(options []decide.Options) map[string]OptimizelyDecision {
+func (o *OptimizelyUserContext) DecideAll(options []decide.OptimizelyDecideOptions) map[string]OptimizelyDecision {
 	return o.optimizely.decideAll(*o, convertDecideOptions(options))
 }
 
 // DecideForKeys returns a key-map of decision results for multiple flag keys and options.
-func (o *OptimizelyUserContext) DecideForKeys(keys []string, options []decide.Options) map[string]OptimizelyDecision {
+func (o *OptimizelyUserContext) DecideForKeys(keys []string, options []decide.OptimizelyDecideOptions) map[string]OptimizelyDecision {
 	return o.optimizely.decideForKeys(*o, keys, convertDecideOptions(options))
 }
 

pkg/client/optimizely_user_context_test.go

@@ -442,7 +442,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideAllEnabledFlagsOnly() {
 	s.Nil(err)
 
 	user := s.OptimizelyClient.CreateUserContext(s.userID, map[string]interface{}{"gender": "f"})
-	decisions := user.DecideAll([]decide.Options{decide.EnabledFlagsOnly})
+	decisions := user.DecideAll([]decide.OptimizelyDecideOptions{decide.EnabledFlagsOnly})
 	s.Len(decisions, 2)
 
 	decision1 := decisions[flagKey1]
@@ -517,7 +517,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideDoNotSendEvent() {
 	flagKey := "feature_2"
 
 	user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
-	decision := user.Decide(flagKey, []decide.Options{decide.DisableDecisionEvent})
+	decision := user.Decide(flagKey, []decide.OptimizelyDecideOptions{decide.DisableDecisionEvent})
 
 	s.Equal("variation_with_traffic", decision.GetVariationKey())
 	s.True(len(s.eventProcessor.Events) == 0)
@@ -558,7 +558,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecisionNotification() {
 
 	receivedNotification = notification.DecisionNotification{}
 	expectedDecisionInfo["decisionEventDispatched"] = false
-	_ = user.Decide(flagKey, []decide.Options{decide.DisableDecisionEvent})
+	_ = user.Decide(flagKey, []decide.OptimizelyDecideOptions{decide.DisableDecisionEvent})
 	s.Equal(expectedDecisionInfo, receivedNotification.DecisionInfo)
 }
 
@@ -590,7 +590,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideOptionsBypassUps() {
 	userProfileService.AssertCalled(s.T(), "Lookup", s.userID)
 	userProfileService.AssertNotCalled(s.T(), "Save", mock.Anything)
 
-	decision = userContext.Decide(flagKey, []decide.Options{decide.IgnoreUserProfileService})
+	decision = userContext.Decide(flagKey, []decide.OptimizelyDecideOptions{decide.IgnoreUserProfileService})
 	// should not lookup, ignore variationId2 set by UPS and return variationId1
 	s.Equal(variationKey1, decision.GetVariationKey())
 	userProfileService.AssertNumberOfCalls(s.T(), "Lookup", 1)
@@ -600,7 +600,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideOptionsBypassUps() {
 
 func (s *OptimizelyUserContextTestSuite) TestDecideOptionsExcludeVariables() {
 	flagKey := "feature_1"
-	options := []decide.Options{}
+	options := []decide.OptimizelyDecideOptions{}
 	user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
 
 	decision := user.Decide(flagKey, options)
@@ -613,7 +613,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideOptionsExcludeVariables() {
 
 func (s *OptimizelyUserContextTestSuite) TestDecideOptionsIncludeReasons() {
 	flagKey := "invalid_key"
-	var options []decide.Options
+	var options []decide.OptimizelyDecideOptions
 	user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
 
 	// invalid flag key
@@ -635,7 +635,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideOptionsIncludeReasons() {
 
 func (s *OptimizelyUserContextTestSuite) TestDefaultDecideOptionsExcludeVariables() {
 	flagKey := "feature_1"
-	options := []decide.Options{decide.ExcludeVariables}
+	options := []decide.OptimizelyDecideOptions{decide.ExcludeVariables}
 	client, _ := s.factory.Client(WithEventProcessor(s.eventProcessor), WithDefaultDecideOptions(options))
 	userContext := client.CreateUserContext(s.userID, nil)
 
@@ -649,7 +649,7 @@ func (s *OptimizelyUserContextTestSuite) TestDefaultDecideOptionsExcludeVariable
 func (s *OptimizelyUserContextTestSuite) TestDefaultDecideOptionsEnabledFlagsOnly() {
 	flagKey := "feature_1"
 	variablesExpected, _ := s.OptimizelyClient.GetAllFeatureVariables(flagKey, entities.UserContext{ID: s.userID})
-	options := []decide.Options{decide.EnabledFlagsOnly}
+	options := []decide.OptimizelyDecideOptions{decide.EnabledFlagsOnly}
 	client, _ := s.factory.Client(WithEventProcessor(s.eventProcessor), WithDefaultDecideOptions(options))
 	user := client.CreateUserContext(s.userID, map[string]interface{}{"gender": "f"})
 
@@ -669,7 +669,7 @@ func (s *OptimizelyUserContextTestSuite) TestDefaultDecideOptionsEnabledFlagsOnl
 
 func (s *OptimizelyUserContextTestSuite) TestDefaultDecideOptionsIncludeReasons() {
 	flagKey := "invalid_key"
-	options := []decide.Options{decide.IncludeReasons}
+	options := []decide.OptimizelyDecideOptions{decide.IncludeReasons}
 	client, _ := s.factory.Client(WithEventProcessor(s.eventProcessor), WithDefaultDecideOptions(options))
 	user := client.CreateUserContext(s.userID, nil)
 
@@ -699,7 +699,7 @@ func (s *OptimizelyUserContextTestSuite) TestDefaultDecideOptionsBypassUps() {
 	userProfileService.On("Lookup", s.userID).Return(savedUserProfile)
 	userProfileService.On("Save", mock.Anything)
 
-	options := []decide.Options{decide.IgnoreUserProfileService}
+	options := []decide.OptimizelyDecideOptions{decide.IgnoreUserProfileService}
 	client, _ := s.factory.Client(WithEventProcessor(s.eventProcessor), WithDefaultDecideOptions(options))
 	user := client.CreateUserContext(s.userID, nil)
 	decision := user.Decide(flagKey, nil)
@@ -712,7 +712,7 @@ func (s *OptimizelyUserContextTestSuite) TestDefaultDecideOptionsBypassUps() {
 }
 
 func (s *OptimizelyUserContextTestSuite) TestGetAllOptionsUsesOrOperator() {
-	options1 := []decide.Options{
+	options1 := []decide.OptimizelyDecideOptions{
 		decide.DisableDecisionEvent,
 		decide.EnabledFlagsOnly,
 		decide.IgnoreUserProfileService,
@@ -721,9 +721,9 @@ func (s *OptimizelyUserContextTestSuite) TestGetAllOptionsUsesOrOperator() {
 	}
 	client, _ := s.factory.Client(WithDefaultDecideOptions(options1))
 	// Pass all false options
-	options2 := client.getAllOptions(&decide.OptimizelyDecideOptions{})
+	options2 := client.getAllOptions(&decide.Options{})
 
-	s.Equal(decide.OptimizelyDecideOptions{
+	s.Equal(decide.Options{
 		DisableDecisionEvent:     true,
 		EnabledFlagsOnly:         true,
 		IgnoreUserProfileService: true,

pkg/decide/decide_options.go

@@ -17,12 +17,12 @@
 // Package decide has option definitions for decide api
 package decide
 
-// Options controlling flag decisions.
-type Options int
+// OptimizelyDecideOptions controlling flag decisions.
+type OptimizelyDecideOptions int
 
 const (
 	// DisableDecisionEvent when set, disables decision event tracking.
-	DisableDecisionEvent Options = 1 + iota
+	DisableDecisionEvent OptimizelyDecideOptions = 1 + iota
 	// EnabledFlagsOnly when set, returns decisions only for flags which are enabled.
 	EnabledFlagsOnly
 	// IgnoreUserProfileService when set, skips user profile service for decision.
@@ -33,8 +33,8 @@ const (
 	ExcludeVariables
 )
 
-// OptimizelyDecideOptions defines options for controlling flag decisions.
-type OptimizelyDecideOptions struct {
+// Options defines options for controlling flag decisions.
+type Options struct {
 	DisableDecisionEvent     bool
 	EnabledFlagsOnly         bool
 	IgnoreUserProfileService bool

pkg/decide/decision_reasons_test.go

@@ -23,12 +23,12 @@ import (
 )
 
 func TestNewDecisionReasonsWithEmptyOptions(t *testing.T) {
-	reasons := NewDecisionReasons(&OptimizelyDecideOptions{})
+	reasons := NewDecisionReasons(&Options{})
 	assert.Equal(t, 0, len(reasons.ToReport()))
 }
 
 func TestAddErrorWorksWithEveryOption(t *testing.T) {
-	options := &OptimizelyDecideOptions{
+	options := &Options{
 		DisableDecisionEvent:     true,
 		EnabledFlagsOnly:         true,
 		IgnoreUserProfileService: true,
@@ -44,7 +44,7 @@ func TestAddErrorWorksWithEveryOption(t *testing.T) {
 }
 
 func TestInfoLogsAreOnlyReportedWhenIncludeReasonsOptionIsSet(t *testing.T) {
-	options := &OptimizelyDecideOptions{
+	options := &Options{
 		DisableDecisionEvent:     true,
 		EnabledFlagsOnly:         true,
 		IgnoreUserProfileService: true,

pkg/decide/default_decision_reasons.go

@@ -28,7 +28,7 @@ type DefaultDecisionReasons struct {
 }
 
 // NewDecisionReasons returns a new instance of DecisionReasons.
-func NewDecisionReasons(options *OptimizelyDecideOptions) *DefaultDecisionReasons {
+func NewDecisionReasons(options *Options) *DefaultDecisionReasons {
 	return &DefaultDecisionReasons{
 		errors:         []string{},
 		logs:           []string{},

pkg/decision/composite_experiment_service.go

@@ -83,7 +83,7 @@ func NewCompositeExperimentService(sdkKey string, options ...CESOptionFunc) *Com
 }
 
 // GetDecision returns a decision for the given experiment and user context
-func (s CompositeExperimentService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext, options *decide.OptimizelyDecideOptions, reasons decide.DecisionReasons) (decision ExperimentDecision, err error) {
+func (s CompositeExperimentService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext, options *decide.Options, reasons decide.DecisionReasons) (decision ExperimentDecision, err error) {
 	// Run through the various decision services until we get a decision
 	for _, experimentService := range s.experimentServices {
 		decision, err = experimentService.GetDecision(decisionContext, userContext, options, reasons)