chore: Add tests for flags handlers (#8)

* Add test for GetAllFeatureFlags

* add test for createFlags

* Bump go

* Add test for flags handlers

dao/err/postgres_error_wrapper.go

@@ -3,6 +3,7 @@ package daoErr
 import (
 	"database/sql"
 	"errors"
+
 	"github.com/lib/pq"
 )
 

dao/flags.go

@@ -2,6 +2,7 @@ package dao
 
 import (
 	"context"
+
 	daoErr "github.com/go-feature-flag/app-api/dao/err"
 	"github.com/go-feature-flag/app-api/model"
 )

dao/inmemory_impl_mock.go

@@ -3,6 +3,7 @@ package dao
 import (
 	"context"
 	"fmt"
+
 	daoErr "github.com/go-feature-flag/app-api/dao/err"
 	"github.com/go-feature-flag/app-api/model"
 	_ "github.com/lib/pq" // we import the driver used by sqlx
@@ -22,11 +23,23 @@ type InMemoryMockDao struct {
 
 // GetFlags return all the flags
 func (m *InMemoryMockDao) GetFlags(ctx context.Context) ([]model.FeatureFlag, daoErr.DaoError) {
+	if ctx.Value("error") != nil {
+		if err, ok := ctx.Value("error").(daoErr.DaoErrorCode); ok {
+			return nil, daoErr.NewDaoError(err, fmt.Errorf("error on get flags"))
+		}
+		return nil, daoErr.NewDaoError(daoErr.UnknownError, fmt.Errorf("error on get flags"))
+	}
 	return m.flags, nil
 }
 
 // GetFlagByID return a flag by its ID
 func (m *InMemoryMockDao) GetFlagByID(ctx context.Context, id string) (model.FeatureFlag, daoErr.DaoError) {
+	if ctx.Value("error") != nil {
+		if err, ok := ctx.Value("error").(daoErr.DaoErrorCode); ok {
+			return model.FeatureFlag{}, daoErr.NewDaoError(err, fmt.Errorf("error on get flag by id"))
+		}
+		return model.FeatureFlag{}, daoErr.NewDaoError(daoErr.UnknownError, fmt.Errorf("error on get flag by id"))
+	}
 	for _, flag := range m.flags {
 		if flag.ID == id {
 			return flag, nil
@@ -37,6 +50,12 @@ func (m *InMemoryMockDao) GetFlagByID(ctx context.Context, id string) (model.Fea
 
 // GetFlagByName return a flag by its name
 func (m *InMemoryMockDao) GetFlagByName(ctx context.Context, name string) (model.FeatureFlag, daoErr.DaoError) {
+	if ctx.Value("error") != nil {
+		if err, ok := ctx.Value("error").(daoErr.DaoErrorCode); ok {
+			return model.FeatureFlag{}, daoErr.NewDaoError(err, fmt.Errorf("error on get flag by name"))
+		}
+		return model.FeatureFlag{}, daoErr.NewDaoError(daoErr.UnknownError, fmt.Errorf("error on get flag by name"))
+	}
 	for _, flag := range m.flags {
 		if flag.Name == name {
 			return flag, nil
@@ -47,11 +66,24 @@ func (m *InMemoryMockDao) GetFlagByName(ctx context.Context, name string) (model
 
 // CreateFlag create a new flag, return the id of the flag
 func (m *InMemoryMockDao) CreateFlag(ctx context.Context, flag model.FeatureFlag) (string, daoErr.DaoError) {
+	if ctx.Value("error_create") != nil {
+		if err, ok := ctx.Value("error_create").(daoErr.DaoErrorCode); ok {
+			return "", daoErr.NewDaoError(err, fmt.Errorf("error creating flag"))
+		}
+		return "", daoErr.NewDaoError(daoErr.UnknownError, fmt.Errorf("error creating flag"))
+	}
+
 	m.flags = append(m.flags, flag)
 	return flag.ID, nil
 }
 
 func (m *InMemoryMockDao) UpdateFlag(ctx context.Context, flag model.FeatureFlag) daoErr.DaoError {
+	if ctx.Value("error_update") != nil {
+		if err, ok := ctx.Value("error_update").(daoErr.DaoErrorCode); ok {
+			return daoErr.NewDaoError(err, fmt.Errorf("error on update flags"))
+		}
+		return daoErr.NewDaoError(daoErr.UnknownError, fmt.Errorf("error on update flags"))
+	}
 	for index, f := range m.flags {
 		if f.ID == flag.ID {
 			m.flags[index] = flag
@@ -62,6 +94,13 @@ func (m *InMemoryMockDao) UpdateFlag(ctx context.Context, flag model.FeatureFlag
 }
 
 func (m *InMemoryMockDao) DeleteFlagByID(ctx context.Context, id string) daoErr.DaoError {
+	if ctx.Value("error_delete") != nil {
+		if err, ok := ctx.Value("error_delete").(daoErr.DaoErrorCode); ok {
+			return daoErr.NewDaoError(err, fmt.Errorf("error on get flags"))
+		}
+		return daoErr.NewDaoError(daoErr.UnknownError, fmt.Errorf("error on get flags"))
+	}
+
 	newInmemoryFlagList := []model.FeatureFlag{}
 	for _, f := range m.flags {
 		if f.ID != id {
@@ -82,3 +121,7 @@ func (m *InMemoryMockDao) Ping() daoErr.DaoError {
 func (m *InMemoryMockDao) OnPingReturnError(v bool) {
 	m.errorOnPing = v
 }
+
+func (m *InMemoryMockDao) SetFlags(flags []model.FeatureFlag) {
+	m.flags = flags
+}

dao/postgres_impl.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+
 	"github.com/go-feature-flag/app-api/dao/dbmodel"
 	daoErr "github.com/go-feature-flag/app-api/dao/err"
 	"github.com/go-feature-flag/app-api/model"

go.mod

@@ -1,6 +1,6 @@
 module github.com/go-feature-flag/app-api
 
-go 1.22.7
+go 1.23.2
 
 require (
 	github.com/google/uuid v1.6.0

handler/flags.go

@@ -1,28 +1,37 @@
 package handler
 
 import (
-	"database/sql"
 	"errors"
 	"fmt"
-	daoErr "github.com/go-feature-flag/app-api/dao/err"
-	"github.com/labstack/echo/v4"
 	"net/http"
-	"time"
 
 	"github.com/go-feature-flag/app-api/dao"
+	daoErr "github.com/go-feature-flag/app-api/dao/err"
 	"github.com/go-feature-flag/app-api/model"
+	"github.com/go-feature-flag/app-api/util"
 	"github.com/google/uuid"
-	"github.com/lib/pq"
+	"github.com/labstack/echo/v4"
 )
 
+type FlagAPIHandlerOptions struct {
+	Clock util.Clock
+}
+
 type FlagAPIHandler struct {
-	dao dao.Flags
+	dao     dao.Flags
+	options *FlagAPIHandlerOptions
 }
 
 // NewFlagAPIHandler creates a new instance of the FlagAPIHandler handler
 // It is a controller class to handle the feature flag configuration logic
-func NewFlagAPIHandler(dao dao.Flags) FlagAPIHandler {
-	return FlagAPIHandler{dao: dao}
+func NewFlagAPIHandler(dao dao.Flags, options *FlagAPIHandlerOptions) FlagAPIHandler {
+	if options == nil {
+		options = &FlagAPIHandlerOptions{}
+	}
+	if options.Clock == nil {
+		options.Clock = util.DefaultClock{}
+	}
+	return FlagAPIHandler{dao: dao, options: options}
 }
 
 // GetAllFeatureFlags is returning the list of all the flags
@@ -87,8 +96,8 @@ func (f FlagAPIHandler) CreateNewFlag(c echo.Context) error {
 	if flag.ID == "" {
 		flag.ID = uuid.NewString()
 	}
-	flag.CreatedDate = time.Now()
-	flag.LastUpdatedDate = time.Now()
+	flag.CreatedDate = f.options.Clock.Now()
+	flag.LastUpdatedDate = f.options.Clock.Now()
 	// TODO: remove this line and extract the information from the token
 	flag.LastModifiedBy = "toto"
 
@@ -105,6 +114,9 @@ func (f FlagAPIHandler) CreateNewFlag(c echo.Context) error {
 
 	id, err := f.dao.CreateFlag(c.Request().Context(), flag)
 	if err != nil {
+		if err.Code() == daoErr.ConversionError {
+			return c.JSON(model.NewHTTPError(http.StatusBadRequest, err))
+		}
 		return c.JSON(model.NewHTTPError(http.StatusInternalServerError, err))
 	}
 	flag.ID = id
@@ -123,8 +135,17 @@ func validateFlag(flag model.FeatureFlag) (int, error) {
 		return status, err
 	}
 
-	if flag.VariationType == "" {
+	switch flag.VariationType {
+	case model.FlagTypeBoolean,
+		model.FlagTypeDouble,
+		model.FlagTypeInteger,
+		model.FlagTypeString,
+		model.FlagTypeJSON:
+		break
+	case "":
 		return http.StatusBadRequest, errors.New("flag type is required")
+	default:
+		return http.StatusBadRequest, fmt.Errorf("flag type %s not supported", flag.VariationType)
 	}
 
 	for _, rule := range flag.GetRules() {
@@ -137,10 +158,15 @@ func validateFlag(flag model.FeatureFlag) (int, error) {
 }
 
 func validateRule(rule *model.Rule, isDefault bool) (int, error) {
-	if rule == nil ||
-		(rule.ProgressiveRollout == nil &&
-			rule.Percentages == nil &&
-			(rule.VariationResult == nil || *rule.VariationResult == "")) {
+	if rule == nil || *rule == (model.Rule{}) {
+		if isDefault {
+			return http.StatusBadRequest, errors.New("flag default rule is required")
+		}
+		return http.StatusBadRequest, errors.New("targeting rule is nil")
+	}
+	if rule.ProgressiveRollout == nil &&
+		rule.Percentages == nil &&
+		(rule.VariationResult == nil || *rule.VariationResult == "") {
 		err := fmt.Errorf("invalid rule %s", rule.Name)
 		if isDefault {
 			err = errors.New("flag default rule is invalid")
@@ -150,7 +176,7 @@ func validateRule(rule *model.Rule, isDefault bool) (int, error) {
 
 	if !isDefault {
 		if rule.Query == "" {
-			return http.StatusBadRequest, errors.New("rule query is required")
+			return http.StatusBadRequest, errors.New("query is required for targeting rules")
 		}
 	}
 	return http.StatusOK, nil
@@ -168,8 +194,7 @@ func validateRule(rule *model.Rule, isDefault bool) (int, error) {
 // @Failure      500 {object} model.HTTPError "Internal server error"
 // @Router       /v1/flags/{id} [put]
 func (f FlagAPIHandler) UpdateFlagByID(c echo.Context) error {
-	// check if the flag exists
-	_, err := f.dao.GetFlagByID(c.Request().Context(), c.Param("id"))
+	retrievedFlag, err := f.dao.GetFlagByID(c.Request().Context(), c.Param("id"))
 	if err != nil {
 		return f.handleDaoError(c, err)
 	}
@@ -187,11 +212,12 @@ func (f FlagAPIHandler) UpdateFlagByID(c echo.Context) error {
 	if flag.ID == "" {
 		flag.ID = c.Param("id")
 	}
-	flag.LastUpdatedDate = time.Now()
+	flag.LastUpdatedDate = f.options.Clock.Now()
+	flag.CreatedDate = retrievedFlag.CreatedDate
 
 	err = f.dao.UpdateFlag(c.Request().Context(), flag)
 	if err != nil {
-		return c.JSON(model.NewHTTPError(http.StatusInternalServerError, err))
+		return f.handleDaoError(c, err)
 	}
 	return c.JSON(http.StatusOK, flag)
 }
@@ -210,19 +236,7 @@ func (f FlagAPIHandler) DeleteFlagByID(c echo.Context) error {
 	idParam := c.Param("id")
 	err := f.dao.DeleteFlagByID(c.Request().Context(), idParam)
 	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return c.JSON(model.NewHTTPError(http.StatusNotFound, fmt.Errorf("flag with id %s not found", idParam)))
-		}
-		var pgErr *pq.Error
-		if errors.As(err, &pgErr) {
-			switch pgErr.Code {
-			case "22P02":
-				return c.JSON(model.NewHTTPError(http.StatusBadRequest, fmt.Errorf("invalid UUID format")))
-			default:
-				return c.JSON(model.NewHTTPError(http.StatusInternalServerError, err))
-			}
-		}
-		return c.JSON(model.NewHTTPError(http.StatusInternalServerError, err))
+		return f.handleDaoError(c, err)
 	}
 	return c.JSON(http.StatusNoContent, nil)
 }
@@ -251,10 +265,10 @@ func (f FlagAPIHandler) UpdateFeatureFlagStatus(c echo.Context) error {
 	}
 
 	flag.Disable = &statusUpdate.Disable
-	flag.LastUpdatedDate = time.Now()
+	flag.LastUpdatedDate = f.options.Clock.Now()
 	err = f.dao.UpdateFlag(c.Request().Context(), flag)
 	if err != nil {
-		return c.JSON(model.NewHTTPError(http.StatusInternalServerError, err))
+		return f.handleDaoError(c, err)
 	}
 	return c.JSON(http.StatusOK, flag)
 }
@@ -263,7 +277,7 @@ func (f FlagAPIHandler) UpdateFeatureFlagStatus(c echo.Context) error {
 func (f FlagAPIHandler) handleDaoError(c echo.Context, err daoErr.DaoError) error {
 	switch err.Code() {
 	case daoErr.NotFound:
-		return c.JSON(model.NewHTTPError(http.StatusNotFound, fmt.Errorf("flag with id %s not found", c.Param("id"))))
+		return c.JSON(model.NewHTTPError(http.StatusNotFound, fmt.Errorf("flag not found")))
 	case daoErr.InvalidUUID:
 		return c.JSON(model.NewHTTPError(http.StatusBadRequest, fmt.Errorf("invalid UUID format")))
 	default: