feat: add custom get env functions (#4)

Author: hgiasac

any.go

@@ -2,8 +2,6 @@ package goenvconf
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
 	"os"
 )
 
@@ -46,10 +44,6 @@ func (ev *EnvAny) UnmarshalJSON(b []byte) error {
 		return err
 	}
 
-	if rawValue.Variable != nil && *rawValue.Variable == "" {
-		return fmt.Errorf("EnvAny: %w", ErrEnvironmentVariableRequired)
-	}
-
 	*ev = EnvAny(rawValue)
 
 	return nil
@@ -63,11 +57,7 @@ func (ev EnvAny) IsZero() bool {
 
 // Get gets literal value or from system environment.
 func (ev EnvAny) Get() (any, error) {
-	if ev.Variable != nil {
-		if *ev.Variable == "" {
-			return nil, fmt.Errorf("EnvAny: %w", ErrEnvironmentVariableRequired)
-		}
-
+	if ev.Variable != nil && *ev.Variable != "" {
 		rawValue := os.Getenv(*ev.Variable)
 		if rawValue != "" {
 			var result any
@@ -81,16 +71,22 @@ func (ev EnvAny) Get() (any, error) {
 	return ev.Value, nil
 }
 
-// GetOrDefault returns the default value if the environment value is empty.
-func (ev EnvAny) GetOrDefault(defaultValue any) (any, error) {
-	result, err := ev.Get()
-	if err != nil {
-		if errors.Is(err, ErrEnvironmentVariableValueRequired) {
-			return defaultValue, nil
+// GetCustom gets literal value or from system environment by a custom function.
+func (ev EnvAny) GetCustom(getFunc GetEnvFunc) (any, error) {
+	if ev.Variable != nil && *ev.Variable != "" {
+		rawValue, err := getFunc(*ev.Variable)
+		if err != nil {
+			return nil, err
 		}
 
-		return false, err
+		if rawValue != "" {
+			var result any
+
+			err := json.Unmarshal([]byte(rawValue), &result)
+
+			return result, err
+		}
 	}
 
-	return result, nil
+	return ev.Value, nil
 }

any_test.go

@@ -1,7 +1,7 @@
 package goenvconf
 
 import (
-	"encoding/json"
+	"errors"
 	"fmt"
 	"testing"
 )
@@ -34,12 +34,6 @@ func TestEnvAny(t *testing.T) {
 			Input:    NewEnvAny("SOME_FOO_2", "baz"),
 			Expected: "baz",
 		},
-		{
-			Input: EnvAny{
-				Variable: toPtr(""),
-			},
-			ErrorMsg: ErrEnvironmentVariableRequired.Error(),
-		},
 	}
 
 	for i, tc := range testCases {
@@ -56,12 +50,118 @@ func TestEnvAny(t *testing.T) {
 			assertDeepEqual(t, tc.Input.IsZero(), tc.Expected == nil)
 		})
 	}
+}
+
+// mockGetEnvFuncForAny creates a mock GetEnvFunc for EnvAny tests
+func mockGetEnvFuncForAny(values map[string]string, returnError bool) GetEnvFunc {
+	return func(key string) (string, error) {
+		if returnError {
+			return "", errors.New("mock error: failed to get environment variable")
+		}
+		if val, ok := values[key]; ok {
+			return val, nil
+		}
+		return "", nil
+	}
+}
+
+func TestEnvAny_GetCustom(t *testing.T) {
+	testCases := []struct {
+		Name     string
+		Input    EnvAny
+		GetFunc  GetEnvFunc
+		Expected any
+		ErrorMsg string
+	}{
+		{
+			Name:     "literal_string_value",
+			Input:    NewEnvAnyValue("hello"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{}, false),
+			Expected: "hello",
+		},
+		{
+			Name:     "literal_number_value",
+			Input:    NewEnvAnyValue(42.5),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{}, false),
+			Expected: 42.5,
+		},
+		{
+			Name:     "literal_map_value",
+			Input:    NewEnvAnyValue(map[string]any{"key": "value"}),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{}, false),
+			Expected: map[string]any{"key": "value"},
+		},
+		{
+			Name:     "variable_from_custom_func_string",
+			Input:    NewEnvAnyVariable("CUSTOM_VAR"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{"CUSTOM_VAR": `"test_string"`}, false),
+			Expected: "test_string",
+		},
+		{
+			Name:     "variable_from_custom_func_number",
+			Input:    NewEnvAnyVariable("CUSTOM_VAR"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{"CUSTOM_VAR": "123.45"}, false),
+			Expected: 123.45,
+		},
+		{
+			Name:     "variable_from_custom_func_json_object",
+			Input:    NewEnvAnyVariable("CUSTOM_VAR"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{"CUSTOM_VAR": `{"foo":"bar","num":42}`}, false),
+			Expected: map[string]any{"foo": "bar", "num": float64(42)},
+		},
+		{
+			Name:     "variable_from_custom_func_json_array",
+			Input:    NewEnvAnyVariable("CUSTOM_VAR"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{"CUSTOM_VAR": `[1,2,3]`}, false),
+			Expected: []any{float64(1), float64(2), float64(3)},
+		},
+		{
+			Name:     "variable_with_fallback_value",
+			Input:    NewEnvAny("CUSTOM_VAR", "fallback"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{"CUSTOM_VAR": `"custom"`}, false),
+			Expected: "custom",
+		},
+		{
+			Name:     "empty_variable_uses_fallback",
+			Input:    NewEnvAny("EMPTY_VAR", "fallback"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{"EMPTY_VAR": ""}, false),
+			Expected: "fallback",
+		},
+		{
+			Name:     "nil_value_and_no_variable",
+			Input:    EnvAny{},
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{}, false),
+			Expected: nil,
+		},
+		{
+			Name:     "custom_func_error",
+			Input:    NewEnvAnyVariable("SOME_VAR"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{}, true),
+			ErrorMsg: "mock error",
+		},
+		{
+			Name:     "invalid_json_format",
+			Input:    NewEnvAnyVariable("INVALID_VAR"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{"INVALID_VAR": `{invalid json`}, false),
+			ErrorMsg: "invalid character",
+		},
+		{
+			Name:     "missing_variable_returns_nil",
+			Input:    NewEnvAnyVariable("MISSING_VAR"),
+			GetFunc:  mockGetEnvFuncForAny(map[string]string{}, false),
+			Expected: nil,
+		},
+	}
 
-	t.Run("json_decode", func(t *testing.T) {
-		var ev EnvAny
-		assertNilError(t, json.Unmarshal([]byte(`{"env": "SOME_FOO"}`), &ev))
-		result, err := ev.GetOrDefault(0)
-		assertNilError(t, err)
-		assertDeepEqual(t, float64(2.2), result)
-	})
+	for _, tc := range testCases {
+		t.Run(tc.Name, func(t *testing.T) {
+			result, err := tc.Input.GetCustom(tc.GetFunc)
+			if tc.ErrorMsg != "" {
+				assertErrorContains(t, err, tc.ErrorMsg)
+			} else {
+				assertNilError(t, err)
+				assertDeepEqual(t, tc.Expected, result)
+			}
+		})
+	}
 }