chore(test): Add test for API implementation (#10)

* chore(test): Add test for dao_error

* chore(test): Add test for UUID generation in rules

* chore(test): Add test for parsing ID parsing error in rules

* chore(test): Add test to postgres implementation

* Add postgres implem test

Author: thomaspoignant

dao/dbmodel/feature_flag.go

@@ -1,6 +1,7 @@
 package dbmodel
 
 import (
+	"errors"
 	"time"
 
 	"github.com/go-feature-flag/app-api/model"
@@ -51,17 +52,23 @@ func FromModelFeatureFlag(mff model.FeatureFlag) (FeatureFlag, error) {
 	return ff, nil
 }
 
-func (ff *FeatureFlag) ToModelFeatureFlag(rules []Rule) model.FeatureFlag {
+func (ff *FeatureFlag) ToModelFeatureFlag(rules []Rule) (model.FeatureFlag, error) {
 	var apiRules = make([]model.Rule, 0)
 	var defaultRule *model.Rule
+	hasDefaultRule := false
 	for _, rule := range rules {
 		convertedRule := rule.ToModelRule()
 		if rule.IsDefault {
+			hasDefaultRule = true
 			defaultRule = &convertedRule
 			continue
 		}
 		apiRules = append(apiRules, convertedRule)
 	}
+	if !hasDefaultRule {
+		return model.FeatureFlag{}, errors.New("default rule is required")
+	}
+
 	variations := make(map[string]interface{})
 	if ff.Variations != nil {
 		variations = ff.Variations
@@ -85,5 +92,6 @@ func (ff *FeatureFlag) ToModelFeatureFlag(rules []Rule) model.FeatureFlag {
 		LastUpdatedDate: ff.LastUpdatedDate,
 		Rules:           &apiRules,
 		DefaultRule:     defaultRule,
-	}
+		LastModifiedBy:  ff.LastModifiedBy,
+	}, nil
 }

dao/dbmodel/feature_flag_test.go

@@ -204,11 +204,47 @@ func TestToModelFeatureFlag(t *testing.T) {
 	ruleId2, _ := uuid.Parse("123e4567-e89b-12d3-a456-426614174222")
 
 	tests := []struct {
-		name   string
-		dbFF   dbmodel.FeatureFlag
-		dbRule []dbmodel.Rule
-		want   model.FeatureFlag
+		name    string
+		dbFF    dbmodel.FeatureFlag
+		dbRule  []dbmodel.Rule
+		want    model.FeatureFlag
+		wantErr assert.ErrorAssertionFunc
 	}{
+		{
+			name: "should error if no default rule",
+			dbFF: dbmodel.FeatureFlag{
+				ID:          flagID,
+				Name:        "my-flag",
+				Description: testutils.String("my flag description"),
+				Variations: dbmodel.JSONB(map[string]interface{}{
+					"A": "a",
+					"B": "b",
+				}),
+				Type:         model.FlagTypeString,
+				BucketingKey: testutils.String("teamID"),
+				Metadata: dbmodel.JSONB(map[string]interface{}{
+					"key": "value",
+				}),
+				TrackEvents:     testutils.Bool(true),
+				Disable:         testutils.Bool(false),
+				Version:         testutils.String("1.0.0"),
+				CreatedDate:     time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC),
+				LastUpdatedDate: time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC),
+			},
+			dbRule: []dbmodel.Rule{
+				{
+					ID:            ruleId1,
+					Name:          "Rule 1",
+					FeatureFlagID: flagID,
+					Disable:       false,
+					Percentages:   testutils.JSONB(dbmodel.JSONB(map[string]interface{}{"A": float64(50), "B": float64(50)})),
+					IsDefault:     false,
+					Query:         testutils.String(`targetingKey eq "foo"`),
+					OrderIndex:    6,
+				},
+			},
+			wantErr: assert.Error,
+		},
 		{
 			name: "should convert model.FeatureFlag to dbmodel.FeatureFlag",
 			dbFF: dbmodel.FeatureFlag{
@@ -236,16 +272,16 @@ func TestToModelFeatureFlag(t *testing.T) {
 					Name:          "Rule 1",
 					FeatureFlagID: flagID,
 					Disable:       false,
-					Percentages:   dbmodel.JSONB(map[string]interface{}{"A": float64(50), "B": float64(50)}),
+					Percentages:   testutils.JSONB(dbmodel.JSONB(map[string]interface{}{"A": float64(50), "B": float64(50)})),
 					IsDefault:     false,
-					Query:         `targetingKey eq "foo"`,
+					Query:         testutils.String(`targetingKey eq "foo"`),
 					OrderIndex:    6,
 				},
 				{
 					ID:                                  ruleId2,
 					Name:                                "rule 2",
 					FeatureFlagID:                       flagID,
-					Query:                               `targetingKey eq "bar"`,
+					Query:                               testutils.String(`targetingKey eq "bar"`),
 					Disable:                             true,
 					OrderIndex:                          10,
 					IsDefault:                           false,
@@ -265,6 +301,7 @@ func TestToModelFeatureFlag(t *testing.T) {
 					IsDefault:       true,
 				},
 			},
+			wantErr: assert.NoError,
 			want: model.FeatureFlag{
 				ID:          flagID.String(),
 				Name:        "my-flag",
@@ -320,7 +357,8 @@ func TestToModelFeatureFlag(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := tt.dbFF.ToModelFeatureFlag(tt.dbRule)
+			got, err := tt.dbFF.ToModelFeatureFlag(tt.dbRule)
+			tt.wantErr(t, err)
 			assert.Equalf(t, tt.want, got, "FromModelFeatureFlag")
 		})
 	}

dao/dbmodel/rule.go

@@ -12,9 +12,9 @@ type Rule struct {
 	FeatureFlagID                       uuid.UUID  `db:"feature_flag_id"`
 	IsDefault                           bool       `db:"is_default"`
 	Name                                string     `db:"name"`
-	Query                               string     `db:"query"`
+	Query                               *string    `db:"query"`
 	VariationResult                     *string    `db:"variation_result"`
-	Percentages                         JSONB      `db:"percentages"` // JSONB is stored as string
+	Percentages                         *JSONB     `db:"percentages"` // JSONB is stored as string
 	Disable                             bool       `db:"disable"`
 	ProgressiveRolloutInitialVariation  *string    `db:"progressive_rollout_initial_variation"`
 	ProgressiveRolloutEndVariation      *string    `db:"progressive_rollout_end_variation"`
@@ -48,7 +48,7 @@ func FromModelRule(mr model.Rule, featureFlagID uuid.UUID, isDefault bool, order
 		FeatureFlagID: featureFlagID,
 		IsDefault:     isDefault,
 		Name:          mr.Name,
-		Query:         mr.Query,
+		Query:         &mr.Query,
 		Disable:       mr.Disable,
 		OrderIndex:    orderIndex,
 	}
@@ -62,7 +62,8 @@ func FromModelRule(mr model.Rule, featureFlagID uuid.UUID, isDefault bool, order
 		for k, v := range *mr.Percentages {
 			percentages[k] = v
 		}
-		dbr.Percentages = JSONB(percentages)
+		jsonbPercentages := JSONB(percentages)
+		dbr.Percentages = &jsonbPercentages
 	}
 
 	if mr.ProgressiveRollout != nil {
@@ -80,16 +81,16 @@ func (rule *Rule) ToModelRule() model.Rule {
 	apiRule := model.Rule{
 		ID:      rule.ID.String(),
 		Name:    rule.Name,
-		Query:   rule.Query,
 		Disable: rule.Disable,
 	}
-
+	if rule.Query != nil {
+		apiRule.Query = *rule.Query
+	}
 	if rule.VariationResult != nil {
 		apiRule.VariationResult = rule.VariationResult
 	}
-
 	if rule.Percentages != nil {
-		for k, v := range rule.Percentages {
+		for k, v := range *rule.Percentages {
 			if apiRule.Percentages == nil {
 				apiRule.Percentages = &map[string]float64{}
 			}

dao/dbmodel/rule_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/go-feature-flag/app-api/testutils"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFromModelRule(t *testing.T) {
@@ -46,7 +47,7 @@ func TestFromModelRule(t *testing.T) {
 				ID:              ruleID,
 				Name:            "defaultRule",
 				FeatureFlagID:   flagID,
-				Query:           "",
+				Query:           testutils.String(""),
 				Disable:         false,
 				OrderIndex:      -1,
 				VariationResult: testutils.String("A"),
@@ -73,7 +74,7 @@ func TestFromModelRule(t *testing.T) {
 				ID:              ruleID,
 				Name:            "rule 1",
 				FeatureFlagID:   flagID,
-				Query:           `targetingKey eq "foo"`,
+				Query:           testutils.String(`targetingKey eq "foo"`),
 				Disable:         true,
 				OrderIndex:      10,
 				VariationResult: testutils.String("A"),
@@ -103,11 +104,11 @@ func TestFromModelRule(t *testing.T) {
 				ID:            ruleID,
 				Name:          "rule 1",
 				FeatureFlagID: flagID,
-				Query:         `targetingKey eq "foo"`,
+				Query:         testutils.String(`targetingKey eq "foo"`),
 				Disable:       true,
 				OrderIndex:    10,
 				IsDefault:     false,
-				Percentages: dbmodel.JSONB(map[string]interface{}{
+				Percentages: testutils.JSONB(map[string]interface{}{
 					"A": float64(50),
 					"B": float64(50),
 				}),
@@ -144,7 +145,7 @@ func TestFromModelRule(t *testing.T) {
 				ID:                                  ruleID,
 				Name:                                "rule 1",
 				FeatureFlagID:                       flagID,
-				Query:                               `targetingKey eq "foo"`,
+				Query:                               testutils.String(`targetingKey eq "foo"`),
 				Disable:                             true,
 				OrderIndex:                          10,
 				IsDefault:                           false,
@@ -167,3 +168,53 @@ func TestFromModelRule(t *testing.T) {
 		})
 	}
 }
+
+func TestFromModelRuleCreateUUID(t *testing.T) {
+	rule := model.Rule{
+		Name: "rule 1",
+		ProgressiveRollout: &model.ProgressiveRollout{
+			Initial: &model.ProgressiveRolloutStep{
+				Variation:  testutils.String("A"),
+				Percentage: testutils.Float64(0),
+				Date:       testutils.Time(time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)),
+			},
+			End: &model.ProgressiveRolloutStep{
+				Variation:  testutils.String("B"),
+				Percentage: testutils.Float64(100),
+				Date:       testutils.Time(time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC)),
+			},
+		},
+		Query:   `targetingKey eq "foo"`,
+		Disable: true,
+	}
+
+	got, err := dbmodel.FromModelRule(rule, uuid.New(), false, 1)
+	require.NoError(t, err)
+	assert.NotNil(t, got.ID)
+	assert.NotEqual(t, uuid.Nil, got.ID)
+}
+
+func TestFromModelRuleErrorParsingUUID(t *testing.T) {
+	rule := model.Rule{
+		Name: "rule 1",
+		ID:   "invalid-uuid",
+		ProgressiveRollout: &model.ProgressiveRollout{
+			Initial: &model.ProgressiveRolloutStep{
+				Variation:  testutils.String("A"),
+				Percentage: testutils.Float64(0),
+				Date:       testutils.Time(time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)),
+			},
+			End: &model.ProgressiveRolloutStep{
+				Variation:  testutils.String("B"),
+				Percentage: testutils.Float64(100),
+				Date:       testutils.Time(time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC)),
+			},
+		},
+		Query:   `targetingKey eq "foo"`,
+		Disable: true,
+	}
+
+	_, err := dbmodel.FromModelRule(rule, uuid.New(), false, 1)
+	require.Error(t, err)
+	assert.Equal(t, "invalid UUID length: 12", err.Error())
+}

dao/err/dao_error.go

@@ -1,5 +1,7 @@
 package daoerr
 
+import "errors"
+
 type DaoErrorCode string
 
 const (
@@ -17,6 +19,10 @@ type DaoError interface {
 }
 
 func NewDaoError(code DaoErrorCode, err error) DaoError {
+	if err == nil {
+		err = errors.New("unknown error")
+	}
+
 	return daoError{
 		error: err,
 		code:  code,

dao/err/dao_error_test.go

@@ -0,0 +1,48 @@
+package daoerr_test
+
+import (
+	"fmt"
+	"testing"
+
+	daoerr "github.com/go-feature-flag/app-api/dao/err"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewDaoError(t *testing.T) {
+	type args struct {
+		code daoerr.DaoErrorCode
+		err  error
+	}
+	tests := []struct {
+		name     string
+		args     args
+		wantErr  error
+		wantCode daoerr.DaoErrorCode
+	}{
+		{
+			name: "Should be able to create a new DaoError",
+			args: args{
+				code: daoerr.NotFound,
+				err:  fmt.Errorf("not found"),
+			},
+			wantErr:  fmt.Errorf("not found"),
+			wantCode: daoerr.NotFound,
+		},
+		{
+			name: "Should not fail with a nil error",
+			args: args{
+				code: daoerr.NotFound,
+				err:  nil,
+			},
+			wantErr:  fmt.Errorf("unknown error"),
+			wantCode: daoerr.NotFound,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := daoerr.NewDaoError(tt.args.code, tt.args.err)
+			assert.Equal(t, tt.wantErr.Error(), err.Error())
+			assert.Equal(t, tt.wantCode, err.Code())
+		})
+	}
+}

dao/err/postgres_error_wrapper.go

@@ -4,17 +4,20 @@ import (
 	"database/sql"
 	"errors"
 
+	"github.com/google/uuid"
 	"github.com/lib/pq"
 )
 
 // WrapPostgresError wraps a postgres error into a DaoError to have a DB agnostic error handling in the handlers
 func WrapPostgresError(err error) DaoError {
-	if errors.Is(err, sql.ErrNoRows) {
-		return NewDaoError(NotFound, err)
-	}
 	var pqErr *pq.Error
-	if errors.As(err, &pqErr) && pqErr.Code == "22P02" {
+	switch {
+	case errors.Is(err, sql.ErrNoRows):
+		return NewDaoError(NotFound, err)
+	case uuid.IsInvalidLengthError(err), errors.As(err, &pqErr) && pqErr.Code == "22P02":
 		return NewDaoError(InvalidUUID, err)
+	default:
+		return NewDaoError(UnknownError, err)
+
 	}
-	return NewDaoError(UnknownError, err)
 }