FF-2022 Add bandits (#50)

* refactor(httpclient): return []bytes instead of converting to string

* refactor(client): make client hold configurationStore directly

With this refactoring, configurationRequestor doesn't need to proxy
get configuration requests to configurationStore.

This also makes configRequestor/poller optional in the client which
simplifies the testing.

* FF-2022 Add bandits

* FF-2022 Update to support non-bandit flag test case

* FF-2022 refactor: banditModelData.evaluate() cannot fail now

* refactor: rename ufc -> flags/config

* test: skip dynamically-typed test cases

Author: rasendubi

eppoclient/assignmentlogger.go

@@ -6,6 +6,14 @@ type IAssignmentLogger interface {
 	LogAssignment(event AssignmentEvent)
 }
 
+// BanditActionLogger is going to be merged into IAssignmentLogger in
+// the next major version.
+type BanditActionLogger interface {
+	LogBanditAction(event BanditEvent)
+}
+
+// TODO: in the next major release, upgrade Timestamp fields to time.Time.
+
 type AssignmentEvent struct {
 	Experiment        string            `json:"experiment"`
 	FeatureFlag       string            `json:"featureFlag"`
@@ -17,6 +25,21 @@ type AssignmentEvent struct {
 	MetaData          map[string]string `json:"metaData"`
 	ExtraLogging      map[string]string `json:"extraLogging,omitempty"`
 }
+type BanditEvent struct {
+	FlagKey                      string             `json:"flagKey"`
+	BanditKey                    string             `json:"banditKey"`
+	Subject                      string             `json:"subject"`
+	Action                       string             `json:"action,omitempty"`
+	ActionProbability            float64            `json:"actionProbability,omitempty"`
+	OptimalityGap                float64            `json:"optimalityGap,omitempty"`
+	ModelVersion                 string             `json:"modelVersion,omitempty"`
+	Timestamp                    string             `json:"timestamp"`
+	SubjectNumericAttributes     map[string]float64 `json:"subjectNumericAttributes,omitempty"`
+	SubjectCategoricalAttributes map[string]string  `json:"subjectCategoricalAttributes,omitempty"`
+	ActionNumericAttributes      map[string]float64 `json:"actionNumericAttributes,omitempty"`
+	ActionCategoricalAttributes  map[string]string  `json:"actionCategoricalAttributes,omitempty"`
+	MetaData                     map[string]string  `json:"metaData"`
+}
 
 type AssignmentLogger struct {
 }
@@ -29,3 +52,8 @@ func (al *AssignmentLogger) LogAssignment(event AssignmentEvent) {
 	fmt.Println("Assignment Logged")
 	fmt.Println(event)
 }
+
+func (al *AssignmentLogger) LogBanditAction(event BanditEvent) {
+	fmt.Println("Bandit Action Logged")
+	fmt.Println(event)
+}

eppoclient/banditmodel.go

@@ -0,0 +1,51 @@
+package eppoclient
+
+import "time"
+
+type banditResponse struct {
+	Bandits   map[string]banditConfiguration `json:"bandits"`
+	UpdatedAt time.Time                      `json:"updatedAt"`
+}
+
+type banditConfiguration struct {
+	BanditKey    string          `json:"banditKey"`
+	ModelName    string          `json:"modelName"`
+	ModelVersion string          `json:"modelVersion"`
+	ModelData    banditModelData `json:"modelData"`
+	UpdatedAt    time.Time       `json:"updatedAt"`
+}
+
+type banditModelData struct {
+	Gamma                  float64                       `json:"gamma"`
+	DefaultActionScore     float64                       `json:"defaultActionScore"`
+	ActionProbabilityFloor float64                       `json:"actionProbabilityFloor"`
+	Coefficients           map[string]banditCoefficients `json:"coefficients"`
+}
+
+type banditCoefficients struct {
+	ActionKey                      string                                  `json:"actionKey"`
+	Intercept                      float64                                 `json:"intercept"`
+	SubjectNumericCoefficients     []banditNumericAttributeCoefficient     `json:"subjectNumericCoefficients"`
+	SubjectCategoricalCoefficients []banditCategoricalAttributeCoefficient `json:"subjectCategoricalCoefficients"`
+	ActionNumericCoefficients      []banditNumericAttributeCoefficient     `json:"actionNumericCoefficients"`
+	ActionCategoricalCoefficients  []banditCategoricalAttributeCoefficient `json:"actionCategoricalCoefficients"`
+}
+
+type banditCategoricalAttributeCoefficient struct {
+	AttributeKey            string             `json:"attributeKey"`
+	MissingValueCoefficient float64            `json:"missingValueCoefficient"`
+	ValueCoefficients       map[string]float64 `json:"valueCoefficients"`
+}
+
+type banditNumericAttributeCoefficient struct {
+	AttributeKey            string  `json:"attributeKey"`
+	Coefficient             float64 `json:"coefficient"`
+	MissingValueCoefficient float64 `json:"missingValueCoefficient"`
+}
+
+type banditVariation struct {
+	Key            string `json:"key"`
+	FlagKey        string `json:"flagKey"`
+	VariationKey   string `json:"variationKey"`
+	VariationValue string `json:"variationValue"`
+}

eppoclient/banditmodel_test.go

@@ -0,0 +1,27 @@
+package eppoclient
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_banditResponse_parseTestFile(t *testing.T) {
+	banditResponse := banditResponse{}
+
+	file, err := os.Open("test-data/ufc/bandit-models-v1.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+
+	decoder := json.NewDecoder(file)
+	err = decoder.Decode(&banditResponse)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.NotEmpty(t, banditResponse.Bandits)
+}

eppoclient/bandits_test.go

@@ -0,0 +1,135 @@
+package eppoclient
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type banditTest struct {
+	Flag         string
+	DefaultValue string
+	Subjects     []struct {
+		SubjectKey        string
+		SubjectAttributes struct {
+			Numeric     map[string]float64 `json:"numericAttributes"`
+			Categorical map[string]string  `json:"categoricalAttributes"`
+		}
+		Actions []struct {
+			ActionKey             string
+			NumericAttributes     map[string]float64
+			CategoricalAttributes map[string]string
+		}
+		Assignment BanditResult
+	}
+}
+
+func Test_InferContextAttributes(t *testing.T) {
+	attributes := Attributes{
+		"string": "blah",
+		"int":    42,
+		"bool":   true,
+	}
+	contextAttributes := InferContextAttributes(attributes)
+
+	expected := ContextAttributes{
+		Numeric: map[string]float64{
+			"int": 42.0,
+		},
+		Categorical: map[string]string{
+			"string": "blah",
+			"bool":   "true",
+		},
+	}
+
+	assert.Equal(t, expected, contextAttributes)
+}
+
+func Test_bandits_sdkTestData(t *testing.T) {
+	flags := readJsonFile[configResponse]("test-data/ufc/bandit-flags-v1.json")
+	bandits := readJsonFile[banditResponse]("test-data/ufc/bandit-models-v1.json")
+	configStore := newConfigurationStore(configuration{
+		flags:   flags,
+		bandits: bandits,
+	})
+	logger := new(mockLogger)
+	logger.Mock.On("LogAssignment", mock.Anything).Return()
+	logger.Mock.On("LogBanditAction", mock.Anything).Return()
+	client := newEppoClient(configStore, nil, nil, logger)
+
+	tests := readJsonDirectory[banditTest]("test-data/ufc/bandit-tests/")
+	for file, test := range tests {
+		t.Run(file, func(t *testing.T) {
+			for _, subject := range test.Subjects {
+				t.Run(subject.SubjectKey, func(t *testing.T) {
+					actions := make(map[string]ContextAttributes)
+					for _, a := range subject.Actions {
+						actions[a.ActionKey] = ContextAttributes{
+							Numeric:     a.NumericAttributes,
+							Categorical: a.CategoricalAttributes,
+						}
+					}
+
+					result := client.GetBanditAction(
+						test.Flag,
+						subject.SubjectKey,
+						ContextAttributes{
+							Numeric:     subject.SubjectAttributes.Numeric,
+							Categorical: subject.SubjectAttributes.Categorical,
+						},
+						actions,
+						test.DefaultValue)
+
+					assert.Equal(t, subject.Assignment, result)
+				})
+			}
+		})
+	}
+}
+
+func readJsonFile[T any](filePath string) T {
+	jsonFile, err := os.Open(filePath)
+	if err != nil {
+		panic(err)
+	}
+	defer jsonFile.Close()
+
+	byteValue, err := io.ReadAll(jsonFile)
+	if err != nil {
+		panic(err)
+	}
+
+	var target T
+	err = json.Unmarshal(byteValue, &target)
+	if err != nil {
+		panic(err)
+	}
+
+	return target
+}
+
+func readJsonDirectory[T any](dirPath string) map[string]T {
+	results := make(map[string]T)
+
+	err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() && filepath.Ext(path) == ".json" && !strings.Contains(filepath.Base(path), ".dynamic-typing.") {
+			results[filepath.Base(path)] = readJsonFile[T](path)
+		}
+		return nil
+	})
+
+	if err != nil {
+		panic(err)
+	}
+
+	return results
+}