webhooker/internal/config/config_test.go

package config_test

import (
	"os"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/fx"
	"go.uber.org/fx/fxtest"
	"sneak.berlin/go/webhooker/internal/config"
	"sneak.berlin/go/webhooker/internal/globals"
	"sneak.berlin/go/webhooker/internal/logger"
)

func TestEnvironmentConfig(t *testing.T) {
	tests := []struct {
		name        string
		envValue    string
		envVars     map[string]string
		expectError bool
		isDev       bool
		isProd      bool
	}{
		{
			name:   "default is dev",
			isDev:  true,
			isProd: false,
		},
		{
			name:     "explicit dev",
			envValue: "dev",
			isDev:    true,
			isProd:   false,
		},
		{
			name:     "explicit prod",
			envValue: "prod",
			isDev:    false,
			isProd:   true,
		},
		{
			name:        "invalid environment",
			envValue:    "staging",
			expectError: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Cannot use t.Parallel() here because t.Setenv
			// is incompatible with parallel subtests.
			if tt.envValue != "" {
				t.Setenv(
					"WEBHOOKER_ENVIRONMENT", tt.envValue,
				)
			} else {
				require.NoError(t, os.Unsetenv(
					"WEBHOOKER_ENVIRONMENT",
				))
			}

			for k, v := range tt.envVars {
				t.Setenv(k, v)
			}

			if tt.expectError {
				testEnvironmentConfigError(t)
			} else {
				testEnvironmentConfigSuccess(
					t, tt.isDev, tt.isProd,
				)
			}
		})
	}
}

func testEnvironmentConfigError(t *testing.T) {
	t.Helper()

	var cfg *config.Config

	app := fx.New(
		fx.NopLogger,
		fx.Provide(
			globals.New,
			logger.New,
			config.New,
		),
		fx.Populate(&cfg),
	)

	assert.Error(t, app.Err())
}

func testEnvironmentConfigSuccess(
	t *testing.T,
	isDev, isProd bool,
) {
	t.Helper()

	var cfg *config.Config

	app := fxtest.New(
		t,
		fx.Provide(
			globals.New,
			logger.New,
			config.New,
		),
		fx.Populate(&cfg),
	)
	require.NoError(t, app.Err())

	app.RequireStart()

	defer app.RequireStop()

	assert.Equal(t, isDev, cfg.IsDev())
	assert.Equal(t, isProd, cfg.IsProd())
}

func TestRetentionSweepInterval(t *testing.T) {
	tests := []struct {
		name        string
		set         bool
		value       string
		expectError bool
		expected    time.Duration
	}{
		{
			name:     "unset uses default",
			set:      false,
			expected: time.Hour,
		},
		{
			name:     "valid value is parsed",
			set:      true,
			value:    "15m",
			expected: 15 * time.Minute,
		},
		{
			name:        "unparseable value fails startup",
			set:         true,
			value:       "not-a-duration",
			expectError: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Cannot use t.Parallel() here because t.Setenv
			// is incompatible with parallel subtests.
			t.Setenv("WEBHOOKER_ENVIRONMENT", "dev")

			if tt.set {
				t.Setenv("RETENTION_SWEEP_INTERVAL", tt.value)
			} else {
				require.NoError(t, os.Unsetenv(
					"RETENTION_SWEEP_INTERVAL",
				))
			}

			if tt.expectError {
				testRetentionSweepIntervalError(t)
			} else {
				testRetentionSweepIntervalSuccess(t, tt.expected)
			}
		})
	}
}

func testRetentionSweepIntervalError(t *testing.T) {
	t.Helper()

	var cfg *config.Config

	app := fx.New(
		fx.NopLogger,
		fx.Provide(
			globals.New,
			logger.New,
			config.New,
		),
		fx.Populate(&cfg),
	)

	assert.Error(t, app.Err())
}

func testRetentionSweepIntervalSuccess(
	t *testing.T,
	expected time.Duration,
) {
	t.Helper()

	var cfg *config.Config

	app := fxtest.New(
		t,
		fx.Provide(
			globals.New,
			logger.New,
			config.New,
		),
		fx.Populate(&cfg),
	)
	require.NoError(t, app.Err())

	app.RequireStart()

	defer app.RequireStop()

	assert.Equal(t, expected, cfg.RetentionSweepInterval)
}

func TestDefaultDataDir(t *testing.T) {
	for _, env := range []string{"", "dev", "prod"} {
		name := env
		if name == "" {
			name = "unset"
		}

		t.Run("env="+name, func(t *testing.T) {
			// Cannot use t.Parallel() here because t.Setenv
			// is incompatible with parallel subtests.
			if env != "" {
				t.Setenv("WEBHOOKER_ENVIRONMENT", env)
			} else {
				require.NoError(t, os.Unsetenv(
					"WEBHOOKER_ENVIRONMENT",
				))
			}

			require.NoError(t, os.Unsetenv("DATA_DIR"))

			var cfg *config.Config

			app := fxtest.New(
				t,
				fx.Provide(
					globals.New,
					logger.New,
					config.New,
				),
				fx.Populate(&cfg),
			)
			require.NoError(t, app.Err())

			app.RequireStart()

			defer app.RequireStop()

			assert.Equal(
				t, "/var/lib/webhooker", cfg.DataDir,
			)
		})
	}
}