diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b821c17..273c36b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -34,6 +34,12 @@ jobs: exit 1 fi + - name: Install mockgen + run: go install go.uber.org/mock/mockgen@latest + + - name: Run go generate + run: go generate ./... + - name: Run golangci-lint uses: golangci/golangci-lint-action@v9 diff --git a/go.mod b/go.mod index 3cd1c7d..032d0d7 100644 --- a/go.mod +++ b/go.mod @@ -6,6 +6,7 @@ require ( github.com/danielgtaylor/huma/v2 v2.34.1 github.com/go-chi/chi/v5 v5.2.3 github.com/stretchr/testify v1.11.1 + go.uber.org/mock v0.6.0 ) require ( diff --git a/go.sum b/go.sum index 96aa749..04c83ce 100644 --- a/go.sum +++ b/go.sum @@ -18,6 +18,8 @@ github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/internal/flags/service.go b/internal/flags/service.go index f47b661..360273e 100644 --- a/internal/flags/service.go +++ b/internal/flags/service.go @@ -21,19 +21,23 @@ func NewServiceWithMatcher(repo Repository, matcher RuleMatcher) *Service { } } -func (s *Service) Create(ctx context.Context, flag *Flag) error { +func (s *Service) Create(ctx context.Context, flag Flag) (Flag, error) { flag.UpdatedAt = time.Now() - return s.repo.Create(ctx, flag) + if err := s.repo.Create(ctx, &flag); err != nil { + return Flag{}, err + } + + return flag, nil } -func (s *Service) Evaluate(ctx context.Context, key string, evalCtx EvalContext) (*EvalResult, error) { +func (s *Service) Evaluate(ctx context.Context, key string, evalCtx EvalContext) (EvalResult, error) { flag, err := s.repo.Get(ctx, key) if err != nil { - return nil, err + return EvalResult{}, err } - result := &EvalResult{ + result := EvalResult{ FlagKey: key, EvaluatedAt: time.Now(), } diff --git a/internal/flags/service_test.go b/internal/flags/service_test.go index 04c4057..9cd29e7 100644 --- a/internal/flags/service_test.go +++ b/internal/flags/service_test.go @@ -16,17 +16,18 @@ func TestService_Create(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + input := flags.Flag{ Key: "new-feature", Type: flags.FlagBool, Enabled: true, DefaultValue: flags.BoolValue(false), } - err := svc.Create(ctx, flag) + created, err := svc.Create(ctx, input) require.NoError(t, err) - assert.False(t, flag.UpdatedAt.IsZero()) + assert.Equal(t, "new-feature", created.Key) + assert.False(t, created.UpdatedAt.IsZero()) } func TestService_Create_Duplicate(t *testing.T) { @@ -36,15 +37,16 @@ func TestService_Create_Duplicate(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + input := flags.Flag{ Key: "new-feature", Type: flags.FlagBool, Enabled: true, } - require.NoError(t, svc.Create(ctx, flag)) - err := svc.Create(ctx, flag) + _, err := svc.Create(ctx, input) + require.NoError(t, err) + _, err = svc.Create(ctx, input) assert.ErrorIs(t, err, flags.ErrFlagExists) } @@ -55,13 +57,14 @@ func TestService_Evaluate_ReturnsDefault(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "my-flag", Type: flags.FlagBool, Enabled: true, DefaultValue: flags.BoolValue(true), } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "my-flag", flags.EvalContext{}) require.NoError(t, err) @@ -79,13 +82,14 @@ func TestService_Evaluate_DisabledFlag(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "disabled-flag", Type: flags.FlagBool, Enabled: false, DefaultValue: flags.BoolValue(false), } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "disabled-flag", flags.EvalContext{}) require.NoError(t, err) @@ -113,7 +117,7 @@ func TestService_Evaluate_RuleMatch_Equals(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "premium-feature", Type: flags.FlagBool, Enabled: true, @@ -128,7 +132,8 @@ func TestService_Evaluate_RuleMatch_Equals(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "premium-feature", flags.EvalContext{ Attrs: map[string]any{"plan": "premium"}, @@ -147,7 +152,7 @@ func TestService_Evaluate_RuleMatch_NoMatch(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "premium-feature", Type: flags.FlagBool, Enabled: true, @@ -162,7 +167,8 @@ func TestService_Evaluate_RuleMatch_NoMatch(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "premium-feature", flags.EvalContext{ Attrs: map[string]any{"plan": "free"}, @@ -180,7 +186,7 @@ func TestService_Evaluate_RuleMatch_In(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "beta-feature", Type: flags.FlagBool, Enabled: true, @@ -195,7 +201,8 @@ func TestService_Evaluate_RuleMatch_In(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "beta-feature", flags.EvalContext{ TenantID: "tenant-2", @@ -213,7 +220,7 @@ func TestService_Evaluate_RuleMatch_MultipleConditions(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "geo-feature", Type: flags.FlagBool, Enabled: true, @@ -229,7 +236,8 @@ func TestService_Evaluate_RuleMatch_MultipleConditions(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "geo-feature", flags.EvalContext{ Attrs: map[string]any{"plan": "premium", "country": "US"}, @@ -251,7 +259,7 @@ func TestService_Evaluate_RuleMatch_FirstMatchWins(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "tiered-feature", Type: flags.FlagString, Enabled: true, @@ -273,7 +281,8 @@ func TestService_Evaluate_RuleMatch_FirstMatchWins(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "tiered-feature", flags.EvalContext{ Attrs: map[string]any{"plan": "enterprise"}, @@ -291,7 +300,7 @@ func TestService_Evaluate_RuleMatch_StartsWith(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "internal-feature", Type: flags.FlagBool, Enabled: true, @@ -306,7 +315,8 @@ func TestService_Evaluate_RuleMatch_StartsWith(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "internal-feature", flags.EvalContext{ Attrs: map[string]any{"email": "admin@company.com"}, @@ -328,7 +338,7 @@ func TestService_Evaluate_StringValue(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "welcome-message", Type: flags.FlagString, Enabled: true, @@ -343,7 +353,8 @@ func TestService_Evaluate_StringValue(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "welcome-message", flags.EvalContext{ Attrs: map[string]any{"tier": "vip"}, @@ -374,13 +385,14 @@ func TestService_WithCustomMatcher(t *testing.T) { svc := flags.NewServiceWithMatcher(repo, customMatcher) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "test-flag", Type: flags.FlagString, Enabled: true, DefaultValue: flags.StringValue("default"), } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "test-flag", flags.EvalContext{}) require.NoError(t, err) @@ -397,7 +409,7 @@ func TestService_Evaluate_NumberValue(t *testing.T) { svc := flags.NewService(repo) ctx := context.Background() - flag := &flags.Flag{ + flag := flags.Flag{ Key: "rate-limit", Type: flags.FlagNumber, Enabled: true, @@ -419,7 +431,8 @@ func TestService_Evaluate_NumberValue(t *testing.T) { }, }, } - require.NoError(t, svc.Create(ctx, flag)) + _, err := svc.Create(ctx, flag) + require.NoError(t, err) result, err := svc.Evaluate(ctx, "rate-limit", flags.EvalContext{ Attrs: map[string]any{"plan": "enterprise"}, diff --git a/internal/handler/handler.go b/internal/handler/handler.go index 4b7e304..8868597 100644 --- a/internal/handler/handler.go +++ b/internal/handler/handler.go @@ -8,18 +8,23 @@ import ( "github.com/serroba/features/internal/flags" ) +//go:generate mockgen -destination=mock_service_test.go -package=handler_test . FlagService + +type FlagService interface { + Create(ctx context.Context, flag flags.Flag) (flags.Flag, error) + Evaluate(ctx context.Context, key string, evalCtx flags.EvalContext) (flags.EvalResult, error) +} + type Handler struct { - service *flags.Service + service FlagService } -func New(service *flags.Service) *Handler { +func New(service FlagService) *Handler { return &Handler{service: service} } func (h *Handler) CreateFlag(ctx context.Context, req *CreateFlagRequest) (*CreateFlagResponse, error) { - flag := ToFlag(req.Body) - - err := h.service.Create(ctx, flag) + flag, err := h.service.Create(ctx, ToFlag(req.Body)) if err != nil { if errors.Is(err, flags.ErrFlagExists) { return nil, huma.Error409Conflict("flag already exists") diff --git a/internal/handler/handler_test.go b/internal/handler/handler_test.go index 4822a17..7cd2c5a 100644 --- a/internal/handler/handler_test.go +++ b/internal/handler/handler_test.go @@ -4,33 +4,31 @@ import ( "context" "errors" "testing" + "time" "github.com/serroba/features/internal/flags" "github.com/serroba/features/internal/handler" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" ) -type failingRepository struct { - err error -} - -func (r *failingRepository) Get(_ context.Context, _ string) (*flags.Flag, error) { - return nil, r.err -} - -func (r *failingRepository) Create(_ context.Context, _ *flags.Flag) error { - return r.err -} - func TestHandler_CreateFlag(t *testing.T) { t.Parallel() - repo := flags.NewMemoryRepository() - svc := flags.NewService(repo) - h := handler.New(svc) + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) ctx := context.Background() + mockService.EXPECT(). + Create(gomock.Any(), gomock.Any()). + DoAndReturn(func(_ context.Context, flag flags.Flag) (flags.Flag, error) { + flag.UpdatedAt = time.Now() + + return flag, nil + }) + boolVal := true req := &handler.CreateFlagRequest{ Body: handler.CreateFlagBody{ @@ -54,11 +52,15 @@ func TestHandler_CreateFlag(t *testing.T) { func TestHandler_CreateFlag_Duplicate(t *testing.T) { t.Parallel() - repo := flags.NewMemoryRepository() - svc := flags.NewService(repo) - h := handler.New(svc) + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) ctx := context.Background() + mockService.EXPECT(). + Create(gomock.Any(), gomock.Any()). + Return(flags.Flag{}, flags.ErrFlagExists) + req := &handler.CreateFlagRequest{ Body: handler.CreateFlagBody{ Key: "test-flag", @@ -68,37 +70,54 @@ func TestHandler_CreateFlag_Duplicate(t *testing.T) { } _, err := h.CreateFlag(ctx, req) - require.NoError(t, err) - - _, err = h.CreateFlag(ctx, req) require.Error(t, err) assert.Contains(t, err.Error(), "already exists") } -func TestHandler_EvaluateFlag(t *testing.T) { +func TestHandler_CreateFlag_InternalError(t *testing.T) { t.Parallel() - repo := flags.NewMemoryRepository() - svc := flags.NewService(repo) - h := handler.New(svc) + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) ctx := context.Background() - boolVal := true - createReq := &handler.CreateFlagRequest{ + mockService.EXPECT(). + Create(gomock.Any(), gomock.Any()). + Return(flags.Flag{}, errors.New("database connection failed")) + + req := &handler.CreateFlagRequest{ Body: handler.CreateFlagBody{ - Key: "my-flag", + Key: "test-flag", Type: "bool", Enabled: true, - DefaultValue: handler.ValueBody{ - Kind: "bool", - Bool: &boolVal, - }, }, } - _, err := h.CreateFlag(ctx, createReq) - require.NoError(t, err) - evalReq := &handler.EvaluateFlagRequest{ + _, err := h.CreateFlag(ctx, req) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to create flag") +} + +func TestHandler_EvaluateFlag(t *testing.T) { + t.Parallel() + + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) + ctx := context.Background() + + boolVal := true + mockService.EXPECT(). + Evaluate(gomock.Any(), "my-flag", gomock.Any()). + Return(flags.EvalResult{ + FlagKey: "my-flag", + Value: flags.Value{Kind: flags.FlagBool, Bool: &boolVal}, + Reason: flags.ReasonDefault, + EvaluatedAt: time.Now(), + }, nil) + + req := &handler.EvaluateFlagRequest{ Key: "my-flag", Body: handler.EvaluateFlagBody{ TenantID: "tenant-1", @@ -106,7 +125,7 @@ func TestHandler_EvaluateFlag(t *testing.T) { }, } - resp, err := h.EvaluateFlag(ctx, evalReq) + resp, err := h.EvaluateFlag(ctx, req) require.NoError(t, err) assert.Equal(t, "my-flag", resp.Body.FlagKey) @@ -118,11 +137,15 @@ func TestHandler_EvaluateFlag(t *testing.T) { func TestHandler_EvaluateFlag_NotFound(t *testing.T) { t.Parallel() - repo := flags.NewMemoryRepository() - svc := flags.NewService(repo) - h := handler.New(svc) + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) ctx := context.Background() + mockService.EXPECT(). + Evaluate(gomock.Any(), "nonexistent", gomock.Any()). + Return(flags.EvalResult{}, flags.ErrFlagNotFound) + req := &handler.EvaluateFlagRequest{ Key: "nonexistent", Body: handler.EvaluateFlagBody{}, @@ -133,50 +156,33 @@ func TestHandler_EvaluateFlag_NotFound(t *testing.T) { assert.Contains(t, err.Error(), "not found") } -func TestHandler_EvaluateFlag_WithRules(t *testing.T) { +func TestHandler_EvaluateFlag_RuleMatch(t *testing.T) { t.Parallel() - repo := flags.NewMemoryRepository() - svc := flags.NewService(repo) - h := handler.New(svc) + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) ctx := context.Background() - boolFalse := false - boolTrue := true - createReq := &handler.CreateFlagRequest{ - Body: handler.CreateFlagBody{ - Key: "premium-feature", - Type: "bool", - Enabled: true, - DefaultValue: handler.ValueBody{ - Kind: "bool", - Bool: &boolFalse, - }, - Rules: []handler.RuleBody{ - { - ID: "premium-users", - Conditions: []handler.ConditionBody{ - {Attr: "plan", Op: "eq", Value: "premium"}, - }, - Value: handler.ValueBody{ - Kind: "bool", - Bool: &boolTrue, - }, - }, - }, - }, - } - _, err := h.CreateFlag(ctx, createReq) - require.NoError(t, err) + boolVal := true + mockService.EXPECT(). + Evaluate(gomock.Any(), "premium-feature", gomock.Any()). + Return(flags.EvalResult{ + FlagKey: "premium-feature", + Value: flags.Value{Kind: flags.FlagBool, Bool: &boolVal}, + Reason: flags.ReasonRuleMatch, + RuleID: "premium-users", + EvaluatedAt: time.Now(), + }, nil) - evalReq := &handler.EvaluateFlagRequest{ + req := &handler.EvaluateFlagRequest{ Key: "premium-feature", Body: handler.EvaluateFlagBody{ Attrs: map[string]any{"plan": "premium"}, }, } - resp, err := h.EvaluateFlag(ctx, evalReq) + resp, err := h.EvaluateFlag(ctx, req) require.NoError(t, err) assert.Equal(t, "rule_match", resp.Body.Reason) @@ -187,66 +193,44 @@ func TestHandler_EvaluateFlag_WithRules(t *testing.T) { func TestHandler_EvaluateFlag_Disabled(t *testing.T) { t.Parallel() - repo := flags.NewMemoryRepository() - svc := flags.NewService(repo) - h := handler.New(svc) + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) ctx := context.Background() boolVal := false - createReq := &handler.CreateFlagRequest{ - Body: handler.CreateFlagBody{ - Key: "disabled-flag", - Type: "bool", - Enabled: false, - DefaultValue: handler.ValueBody{ - Kind: "bool", - Bool: &boolVal, - }, - }, - } - _, err := h.CreateFlag(ctx, createReq) - require.NoError(t, err) + mockService.EXPECT(). + Evaluate(gomock.Any(), "disabled-flag", gomock.Any()). + Return(flags.EvalResult{ + FlagKey: "disabled-flag", + Value: flags.Value{Kind: flags.FlagBool, Bool: &boolVal}, + Reason: flags.ReasonDisabled, + EvaluatedAt: time.Now(), + }, nil) - evalReq := &handler.EvaluateFlagRequest{ + req := &handler.EvaluateFlagRequest{ Key: "disabled-flag", Body: handler.EvaluateFlagBody{}, } - resp, err := h.EvaluateFlag(ctx, evalReq) + resp, err := h.EvaluateFlag(ctx, req) require.NoError(t, err) assert.Equal(t, "disabled", resp.Body.Reason) } -func TestHandler_CreateFlag_InternalError(t *testing.T) { - t.Parallel() - - repo := &failingRepository{err: errors.New("database connection failed")} - svc := flags.NewService(repo) - h := handler.New(svc) - ctx := context.Background() - - req := &handler.CreateFlagRequest{ - Body: handler.CreateFlagBody{ - Key: "test-flag", - Type: "bool", - Enabled: true, - }, - } - - _, err := h.CreateFlag(ctx, req) - require.Error(t, err) - assert.Contains(t, err.Error(), "failed to create flag") -} - func TestHandler_EvaluateFlag_InternalError(t *testing.T) { t.Parallel() - repo := &failingRepository{err: errors.New("database connection failed")} - svc := flags.NewService(repo) - h := handler.New(svc) + ctrl := gomock.NewController(t) + mockService := NewMockFlagService(ctrl) + h := handler.New(mockService) ctx := context.Background() + mockService.EXPECT(). + Evaluate(gomock.Any(), "test-flag", gomock.Any()). + Return(flags.EvalResult{}, errors.New("database connection failed")) + req := &handler.EvaluateFlagRequest{ Key: "test-flag", Body: handler.EvaluateFlagBody{}, diff --git a/internal/handler/mapper.go b/internal/handler/mapper.go index 037c7df..4b7b8bf 100644 --- a/internal/handler/mapper.go +++ b/internal/handler/mapper.go @@ -4,16 +4,14 @@ import ( "github.com/serroba/features/internal/flags" ) -func ToFlag(body CreateFlagBody) *flags.Flag { - flag := &flags.Flag{ +func ToFlag(body CreateFlagBody) flags.Flag { + return flags.Flag{ Key: body.Key, Type: flags.FlagType(body.Type), Enabled: body.Enabled, DefaultValue: toValue(body.DefaultValue), Rules: toRules(body.Rules), } - - return flag } func toRules(bodies []RuleBody) []flags.Rule { @@ -67,7 +65,7 @@ func ToEvalContext(body EvaluateFlagBody) flags.EvalContext { } } -func ToEvalResultBody(result *flags.EvalResult) EvalResultBody { +func ToEvalResultBody(result flags.EvalResult) EvalResultBody { return EvalResultBody{ FlagKey: result.FlagKey, Value: toValueBody(result.Value), diff --git a/internal/handler/mapper_test.go b/internal/handler/mapper_test.go index 56e4072..fc97e02 100644 --- a/internal/handler/mapper_test.go +++ b/internal/handler/mapper_test.go @@ -89,7 +89,7 @@ func TestToEvalResultBody(t *testing.T) { boolVal := true now := time.Now() - result := &flags.EvalResult{ + result := flags.EvalResult{ FlagKey: "my-flag", Value: flags.Value{ Kind: flags.FlagBool, diff --git a/internal/handler/mock_service_test.go b/internal/handler/mock_service_test.go new file mode 100644 index 0000000..9d0c1e1 --- /dev/null +++ b/internal/handler/mock_service_test.go @@ -0,0 +1,72 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/serroba/features/internal/handler (interfaces: FlagService) +// +// Generated by this command: +// +// mockgen -destination=mock_service_test.go -package=handler_test . FlagService +// + +// Package handler_test is a generated GoMock package. +package handler_test + +import ( + context "context" + reflect "reflect" + + flags "github.com/serroba/features/internal/flags" + gomock "go.uber.org/mock/gomock" +) + +// MockFlagService is a mock of FlagService interface. +type MockFlagService struct { + ctrl *gomock.Controller + recorder *MockFlagServiceMockRecorder + isgomock struct{} +} + +// MockFlagServiceMockRecorder is the mock recorder for MockFlagService. +type MockFlagServiceMockRecorder struct { + mock *MockFlagService +} + +// NewMockFlagService creates a new mock instance. +func NewMockFlagService(ctrl *gomock.Controller) *MockFlagService { + mock := &MockFlagService{ctrl: ctrl} + mock.recorder = &MockFlagServiceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockFlagService) EXPECT() *MockFlagServiceMockRecorder { + return m.recorder +} + +// Create mocks base method. +func (m *MockFlagService) Create(ctx context.Context, flag flags.Flag) (flags.Flag, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", ctx, flag) + ret0, _ := ret[0].(flags.Flag) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockFlagServiceMockRecorder) Create(ctx, flag any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFlagService)(nil).Create), ctx, flag) +} + +// Evaluate mocks base method. +func (m *MockFlagService) Evaluate(ctx context.Context, key string, evalCtx flags.EvalContext) (flags.EvalResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Evaluate", ctx, key, evalCtx) + ret0, _ := ret[0].(flags.EvalResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Evaluate indicates an expected call of Evaluate. +func (mr *MockFlagServiceMockRecorder) Evaluate(ctx, key, evalCtx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Evaluate", reflect.TypeOf((*MockFlagService)(nil).Evaluate), ctx, key, evalCtx) +}