Skip to content

Git designed for AI agents.

3.6 KB
Raw Blame
package limiter

import (
	"context"
	"errors"
	"testing"

	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/stretchr/testify/require"
	"google.golang.org/grpc/metadata"
)

type mockLimiter struct {
	limitFunc func(ctx context.Context, lockKey string, f LimitedFunc) (interface{}, error)
}

func (m *mockLimiter) Limit(ctx context.Context, lockKey string, f LimitedFunc) (interface{}, error) {
	if m.limitFunc != nil {
		return m.limitFunc(ctx, lockKey, f)
	}
	return f()
}

func TestDualLimiter_Limit(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		name                string
		setupContext        func(t *testing.T) context.Context
		expectedLimiterUsed string
	}{
		{
			name: "authenticated request uses authenticated limiter",
			setupContext: func(t *testing.T) context.Context {
				ctx := testhelper.Context(t)
				// Set up authenticated context with username in metadata
				md := metadata.New(map[string]string{
					"username": "test-user",
				})
				return metadata.NewIncomingContext(ctx, md)
			},
			expectedLimiterUsed: "authenticated",
		},
		{
			name: "unauthenticated request uses unauthenticated limiter",
			setupContext: func(t *testing.T) context.Context {
				// Context without authentication (no username in metadata)
				return testhelper.Context(t)
			},
			expectedLimiterUsed: "unauthenticated",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			var usedLimiter string

			authenticatedLimiter := &mockLimiter{
				limitFunc: func(ctx context.Context, lockKey string, f LimitedFunc) (interface{}, error) {
					usedLimiter = "authenticated"
					return f()
				},
			}

			unauthenticatedLimiter := &mockLimiter{
				limitFunc: func(ctx context.Context, lockKey string, f LimitedFunc) (interface{}, error) {
					usedLimiter = "unauthenticated"
					return f()
				},
			}

			dualLimiter := NewDualLimiter(authenticatedLimiter, unauthenticatedLimiter)

			ctx := tc.setupContext(t)

			result, err := dualLimiter.Limit(ctx, "test-key", func() (interface{}, error) {
				return "success", nil
			})

			require.NoError(t, err)
			require.Equal(t, "success", result)
			require.Equal(t, tc.expectedLimiterUsed, usedLimiter)
		})
	}
}

func TestDualLimiter_PropagatesErrors(t *testing.T) {
	t.Parallel()

	expectedErr := errors.New("limiter error")

	t.Run("authenticated limiter error", func(t *testing.T) {
		t.Parallel()

		authenticatedLimiter := &mockLimiter{
			limitFunc: func(ctx context.Context, lockKey string, f LimitedFunc) (interface{}, error) {
				return nil, expectedErr
			},
		}

		unauthenticatedLimiter := &mockLimiter{}

		dualLimiter := NewDualLimiter(authenticatedLimiter, unauthenticatedLimiter)

		ctx := testhelper.Context(t)
		md := metadata.New(map[string]string{
			"username": "test-user",
		})
		ctx = metadata.NewIncomingContext(ctx, md)

		result, err := dualLimiter.Limit(ctx, "test-key", func() (interface{}, error) {
			return "should not be called", nil
		})

		require.ErrorIs(t, err, expectedErr)
		require.Nil(t, result)
	})

	t.Run("unauthenticated limiter error", func(t *testing.T) {
		t.Parallel()

		authenticatedLimiter := &mockLimiter{}

		unauthenticatedLimiter := &mockLimiter{
			limitFunc: func(ctx context.Context, lockKey string, f LimitedFunc) (interface{}, error) {
				return nil, expectedErr
			},
		}

		dualLimiter := NewDualLimiter(authenticatedLimiter, unauthenticatedLimiter)

		ctx := testhelper.Context(t)

		result, err := dualLimiter.Limit(ctx, "test-key", func() (interface{}, error) {
			return "should not be called", nil
		})

		require.ErrorIs(t, err, expectedErr)
		require.Nil(t, result)
	})
}