diff --git a/any.go b/any.go index f6945d7..776843f 100644 --- a/any.go +++ b/any.go @@ -96,9 +96,10 @@ func (ev EnvAny) GetCustom(getFunc GetEnvFunc) (any, error) { func (ev EnvAny) Equal(target EnvAny) bool { isSameValue := (ev.Value == nil && target.Value == nil) || (ev.Value != nil && target.Value != nil && reflect.DeepEqual(ev.Value, target.Value)) + if !isSameValue { + return false + } - isSameEnv := (ev.Variable == nil && target.Variable == nil) || + return (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) - - return isSameValue && isSameEnv } diff --git a/any_equal_test.go b/any_equal_test.go deleted file mode 100644 index 89807eb..0000000 --- a/any_equal_test.go +++ /dev/null @@ -1,150 +0,0 @@ -package goenvconf - -import ( - "testing" -) - -func TestEnvAny_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvAny - Target EnvAny - Expected bool - }{ - { - Name: "both_nil", - Input: EnvAny{}, - Target: EnvAny{}, - Expected: true, - }, - { - Name: "same_string_values", - Input: NewEnvAnyValue("hello"), - Target: NewEnvAnyValue("hello"), - Expected: true, - }, - { - Name: "different_string_values", - Input: NewEnvAnyValue("hello"), - Target: NewEnvAnyValue("world"), - Expected: false, - }, - { - Name: "same_int_values", - Input: NewEnvAnyValue(42), - Target: NewEnvAnyValue(42), - Expected: true, - }, - { - Name: "different_int_values", - Input: NewEnvAnyValue(42), - Target: NewEnvAnyValue(100), - Expected: false, - }, - { - Name: "same_float_values", - Input: NewEnvAnyValue(3.14), - Target: NewEnvAnyValue(3.14), - Expected: true, - }, - { - Name: "different_float_values", - Input: NewEnvAnyValue(3.14), - Target: NewEnvAnyValue(2.718), - Expected: false, - }, - { - Name: "same_bool_values", - Input: NewEnvAnyValue(true), - Target: NewEnvAnyValue(true), - Expected: true, - }, - { - Name: "different_bool_values", - Input: NewEnvAnyValue(true), - Target: NewEnvAnyValue(false), - Expected: false, - }, - { - Name: "same_map_values", - Input: NewEnvAnyValue(map[string]any{"key": "value"}), - Target: NewEnvAnyValue(map[string]any{"key": "value"}), - Expected: true, - }, - { - Name: "different_map_values", - Input: NewEnvAnyValue(map[string]any{"key1": "value1"}), - Target: NewEnvAnyValue(map[string]any{"key2": "value2"}), - Expected: false, - }, - { - Name: "same_slice_values", - Input: NewEnvAnyValue([]any{1, 2, 3}), - Target: NewEnvAnyValue([]any{1, 2, 3}), - Expected: true, - }, - { - Name: "different_slice_values", - Input: NewEnvAnyValue([]any{1, 2, 3}), - Target: NewEnvAnyValue([]any{4, 5, 6}), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvAnyVariable("MY_VAR"), - Target: NewEnvAnyVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvAnyVariable("VAR1"), - Target: NewEnvAnyVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvAny("MY_VAR", "default"), - Target: NewEnvAny("MY_VAR", "default"), - Expected: true, - }, - { - Name: "same_variable_different_value", - Input: NewEnvAny("MY_VAR", "value1"), - Target: NewEnvAny("MY_VAR", "value2"), - Expected: false, - }, - { - Name: "different_variable_same_value", - Input: NewEnvAny("VAR1", "value"), - Target: NewEnvAny("VAR2", "value"), - Expected: false, - }, - { - Name: "value_vs_variable", - Input: NewEnvAnyValue("hello"), - Target: NewEnvAnyVariable("MY_VAR"), - Expected: false, - }, - { - Name: "different_types", - Input: NewEnvAnyValue("42"), - Target: NewEnvAnyValue(42), - Expected: false, - }, - { - Name: "nil_value_vs_non_nil", - Input: NewEnvAnyVariable("MY_VAR"), - Target: NewEnvAnyValue("hello"), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} diff --git a/any_test.go b/any_test.go index f7e3f73..8648d7a 100644 --- a/any_test.go +++ b/any_test.go @@ -165,3 +165,148 @@ func TestEnvAny_GetCustom(t *testing.T) { }) } } + +func TestEnvAny_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvAny + Target EnvAny + Expected bool + }{ + { + Name: "both_nil", + Input: EnvAny{}, + Target: EnvAny{}, + Expected: true, + }, + { + Name: "same_string_values", + Input: NewEnvAnyValue("hello"), + Target: NewEnvAnyValue("hello"), + Expected: true, + }, + { + Name: "different_string_values", + Input: NewEnvAnyValue("hello"), + Target: NewEnvAnyValue("world"), + Expected: false, + }, + { + Name: "same_int_values", + Input: NewEnvAnyValue(42), + Target: NewEnvAnyValue(42), + Expected: true, + }, + { + Name: "different_int_values", + Input: NewEnvAnyValue(42), + Target: NewEnvAnyValue(100), + Expected: false, + }, + { + Name: "same_float_values", + Input: NewEnvAnyValue(3.14), + Target: NewEnvAnyValue(3.14), + Expected: true, + }, + { + Name: "different_float_values", + Input: NewEnvAnyValue(3.14), + Target: NewEnvAnyValue(2.718), + Expected: false, + }, + { + Name: "same_bool_values", + Input: NewEnvAnyValue(true), + Target: NewEnvAnyValue(true), + Expected: true, + }, + { + Name: "different_bool_values", + Input: NewEnvAnyValue(true), + Target: NewEnvAnyValue(false), + Expected: false, + }, + { + Name: "same_map_values", + Input: NewEnvAnyValue(map[string]any{"key": "value"}), + Target: NewEnvAnyValue(map[string]any{"key": "value"}), + Expected: true, + }, + { + Name: "different_map_values", + Input: NewEnvAnyValue(map[string]any{"key1": "value1"}), + Target: NewEnvAnyValue(map[string]any{"key2": "value2"}), + Expected: false, + }, + { + Name: "same_slice_values", + Input: NewEnvAnyValue([]any{1, 2, 3}), + Target: NewEnvAnyValue([]any{1, 2, 3}), + Expected: true, + }, + { + Name: "different_slice_values", + Input: NewEnvAnyValue([]any{1, 2, 3}), + Target: NewEnvAnyValue([]any{4, 5, 6}), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvAnyVariable("MY_VAR"), + Target: NewEnvAnyVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvAnyVariable("VAR1"), + Target: NewEnvAnyVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvAny("MY_VAR", "default"), + Target: NewEnvAny("MY_VAR", "default"), + Expected: true, + }, + { + Name: "same_variable_different_value", + Input: NewEnvAny("MY_VAR", "value1"), + Target: NewEnvAny("MY_VAR", "value2"), + Expected: false, + }, + { + Name: "different_variable_same_value", + Input: NewEnvAny("VAR1", "value"), + Target: NewEnvAny("VAR2", "value"), + Expected: false, + }, + { + Name: "value_vs_variable", + Input: NewEnvAnyValue("hello"), + Target: NewEnvAnyVariable("MY_VAR"), + Expected: false, + }, + { + Name: "different_types", + Input: NewEnvAnyValue("42"), + Target: NewEnvAnyValue(42), + Expected: false, + }, + { + Name: "nil_value_vs_non_nil", + Input: NewEnvAnyVariable("MY_VAR"), + Target: NewEnvAnyValue("hello"), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} diff --git a/environment.go b/environment.go index 21531f0..f06a0a1 100644 --- a/environment.go +++ b/environment.go @@ -66,6 +66,18 @@ func (ev EnvString) IsZero() bool { ev.Value == nil } +// Equal checks if this instance equals the target value. +func (ev EnvString) Equal(target EnvString) bool { + isSameValue := (ev.Value == nil && target.Value == nil) || + (ev.Value != nil && target.Value != nil && *ev.Value == *target.Value) + if !isSameValue { + return false + } + + return (ev.Variable == nil && target.Variable == nil) || + (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) +} + // Get gets literal value or from system environment. func (ev EnvString) Get() (string, error) { if ev.IsZero() { @@ -127,17 +139,6 @@ func (ev EnvString) GetCustom(getFunc GetEnvFunc) (string, error) { return "", getEnvVariableValueRequiredError(ev.Variable) } -// Equal checks if this instance equals the target value. -func (ev EnvString) Equal(target EnvString) bool { - isSameValue := (ev.Value == nil && target.Value == nil) || - (ev.Value != nil && target.Value != nil && *ev.Value == *target.Value) - - isSameEnv := (ev.Variable == nil && target.Variable == nil) || - (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) - - return isSameValue && isSameEnv -} - // EnvInt represents either a literal integer or an environment reference. type EnvInt struct { Value *int64 `json:"value,omitempty" jsonschema:"anyof_required=value" mapstructure:"value" yaml:"value,omitempty"` @@ -176,11 +177,12 @@ func (ev EnvInt) IsZero() bool { func (ev EnvInt) Equal(target EnvInt) bool { isSameValue := (ev.Value == nil && target.Value == nil) || (ev.Value != nil && target.Value != nil && *ev.Value == *target.Value) + if !isSameValue { + return false + } - isSameEnv := (ev.Variable == nil && target.Variable == nil) || + return (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) - - return isSameValue && isSameEnv } // UnmarshalJSON implements json.Unmarshaler. @@ -300,11 +302,12 @@ func (ev EnvBool) IsZero() bool { func (ev EnvBool) Equal(target EnvBool) bool { isSameValue := (ev.Value == nil && target.Value == nil) || (ev.Value != nil && target.Value != nil && *ev.Value == *target.Value) + if !isSameValue { + return false + } - isSameEnv := (ev.Variable == nil && target.Variable == nil) || + return (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) - - return isSameValue && isSameEnv } // UnmarshalJSON implements json.Unmarshaler. @@ -424,11 +427,12 @@ func (ev EnvFloat) IsZero() bool { func (ev EnvFloat) Equal(target EnvFloat) bool { isSameValue := (ev.Value == nil && target.Value == nil) || (ev.Value != nil && target.Value != nil && *ev.Value == *target.Value) + if !isSameValue { + return false + } - isSameEnv := (ev.Variable == nil && target.Variable == nil) || + return (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) - - return isSameValue && isSameEnv } // UnmarshalJSON implements json.Unmarshaler. diff --git a/environment_equal_test.go b/environment_equal_test.go deleted file mode 100644 index 77fef83..0000000 --- a/environment_equal_test.go +++ /dev/null @@ -1,273 +0,0 @@ -package goenvconf - -import ( - "testing" -) - -func TestEnvString_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvString - Target EnvString - Expected bool - }{ - { - Name: "both_nil_values_and_variables", - Input: EnvString{}, - Target: EnvString{}, - Expected: true, - }, - { - Name: "same_literal_values", - Input: NewEnvStringValue("hello"), - Target: NewEnvStringValue("hello"), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvStringValue("hello"), - Target: NewEnvStringValue("world"), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvStringVariable("MY_VAR"), - Target: NewEnvStringVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvStringVariable("VAR1"), - Target: NewEnvStringVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvString("MY_VAR", "default"), - Target: NewEnvString("MY_VAR", "default"), - Expected: true, - }, - { - Name: "same_variable_different_value", - Input: NewEnvString("MY_VAR", "value1"), - Target: NewEnvString("MY_VAR", "value2"), - Expected: false, - }, - { - Name: "different_variable_same_value", - Input: NewEnvString("VAR1", "value"), - Target: NewEnvString("VAR2", "value"), - Expected: false, - }, - { - Name: "value_vs_variable", - Input: NewEnvStringValue("hello"), - Target: NewEnvStringVariable("MY_VAR"), - Expected: false, - }, - { - Name: "nil_value_vs_non_nil", - Input: NewEnvStringVariable("MY_VAR"), - Target: NewEnvStringValue("hello"), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} - -func TestEnvInt_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvInt - Target EnvInt - Expected bool - }{ - { - Name: "both_nil", - Input: EnvInt{}, - Target: EnvInt{}, - Expected: true, - }, - { - Name: "same_literal_values", - Input: NewEnvIntValue(42), - Target: NewEnvIntValue(42), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvIntValue(42), - Target: NewEnvIntValue(100), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvIntVariable("MY_VAR"), - Target: NewEnvIntVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvIntVariable("VAR1"), - Target: NewEnvIntVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvInt("MY_VAR", 42), - Target: NewEnvInt("MY_VAR", 42), - Expected: true, - }, - { - Name: "value_vs_variable", - Input: NewEnvIntValue(42), - Target: NewEnvIntVariable("MY_VAR"), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} - -func TestEnvBool_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvBool - Target EnvBool - Expected bool - }{ - { - Name: "both_nil", - Input: EnvBool{}, - Target: EnvBool{}, - Expected: true, - }, - { - Name: "same_literal_true", - Input: NewEnvBoolValue(true), - Target: NewEnvBoolValue(true), - Expected: true, - }, - { - Name: "same_literal_false", - Input: NewEnvBoolValue(false), - Target: NewEnvBoolValue(false), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvBoolValue(true), - Target: NewEnvBoolValue(false), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvBoolVariable("MY_VAR"), - Target: NewEnvBoolVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvBoolVariable("VAR1"), - Target: NewEnvBoolVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvBool("MY_VAR", true), - Target: NewEnvBool("MY_VAR", true), - Expected: true, - }, - { - Name: "value_vs_variable", - Input: NewEnvBoolValue(true), - Target: NewEnvBoolVariable("MY_VAR"), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} - -func TestEnvFloat_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvFloat - Target EnvFloat - Expected bool - }{ - { - Name: "both_nil", - Input: EnvFloat{}, - Target: EnvFloat{}, - Expected: true, - }, - { - Name: "same_literal_values", - Input: NewEnvFloatValue(3.14), - Target: NewEnvFloatValue(3.14), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvFloatValue(3.14), - Target: NewEnvFloatValue(2.718), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvFloatVariable("MY_VAR"), - Target: NewEnvFloatVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvFloatVariable("VAR1"), - Target: NewEnvFloatVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvFloat("MY_VAR", 3.14), - Target: NewEnvFloat("MY_VAR", 3.14), - Expected: true, - }, - { - Name: "value_vs_variable", - Input: NewEnvFloatValue(3.14), - Target: NewEnvFloatVariable("MY_VAR"), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} diff --git a/environment_test.go b/environment_test.go index 7b4d824..71bf177 100644 --- a/environment_test.go +++ b/environment_test.go @@ -623,3 +623,271 @@ func assertDeepEqual(t *testing.T, expected, reality any) { func toPtr[T any](input T) *T { return &input } + +func TestEnvString_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvString + Target EnvString + Expected bool + }{ + { + Name: "both_nil_values_and_variables", + Input: EnvString{}, + Target: EnvString{}, + Expected: true, + }, + { + Name: "same_literal_values", + Input: NewEnvStringValue("hello"), + Target: NewEnvStringValue("hello"), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvStringValue("hello"), + Target: NewEnvStringValue("world"), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvStringVariable("MY_VAR"), + Target: NewEnvStringVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvStringVariable("VAR1"), + Target: NewEnvStringVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvString("MY_VAR", "default"), + Target: NewEnvString("MY_VAR", "default"), + Expected: true, + }, + { + Name: "same_variable_different_value", + Input: NewEnvString("MY_VAR", "value1"), + Target: NewEnvString("MY_VAR", "value2"), + Expected: false, + }, + { + Name: "different_variable_same_value", + Input: NewEnvString("VAR1", "value"), + Target: NewEnvString("VAR2", "value"), + Expected: false, + }, + { + Name: "value_vs_variable", + Input: NewEnvStringValue("hello"), + Target: NewEnvStringVariable("MY_VAR"), + Expected: false, + }, + { + Name: "nil_value_vs_non_nil", + Input: NewEnvStringVariable("MY_VAR"), + Target: NewEnvStringValue("hello"), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} + +func TestEnvInt_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvInt + Target EnvInt + Expected bool + }{ + { + Name: "both_nil", + Input: EnvInt{}, + Target: EnvInt{}, + Expected: true, + }, + { + Name: "same_literal_values", + Input: NewEnvIntValue(42), + Target: NewEnvIntValue(42), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvIntValue(42), + Target: NewEnvIntValue(100), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvIntVariable("MY_VAR"), + Target: NewEnvIntVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvIntVariable("VAR1"), + Target: NewEnvIntVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvInt("MY_VAR", 42), + Target: NewEnvInt("MY_VAR", 42), + Expected: true, + }, + { + Name: "value_vs_variable", + Input: NewEnvIntValue(42), + Target: NewEnvIntVariable("MY_VAR"), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} + +func TestEnvBool_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvBool + Target EnvBool + Expected bool + }{ + { + Name: "both_nil", + Input: EnvBool{}, + Target: EnvBool{}, + Expected: true, + }, + { + Name: "same_literal_true", + Input: NewEnvBoolValue(true), + Target: NewEnvBoolValue(true), + Expected: true, + }, + { + Name: "same_literal_false", + Input: NewEnvBoolValue(false), + Target: NewEnvBoolValue(false), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvBoolValue(true), + Target: NewEnvBoolValue(false), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvBoolVariable("MY_VAR"), + Target: NewEnvBoolVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvBoolVariable("VAR1"), + Target: NewEnvBoolVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvBool("MY_VAR", true), + Target: NewEnvBool("MY_VAR", true), + Expected: true, + }, + { + Name: "value_vs_variable", + Input: NewEnvBoolValue(true), + Target: NewEnvBoolVariable("MY_VAR"), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} + +func TestEnvFloat_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvFloat + Target EnvFloat + Expected bool + }{ + { + Name: "both_nil", + Input: EnvFloat{}, + Target: EnvFloat{}, + Expected: true, + }, + { + Name: "same_literal_values", + Input: NewEnvFloatValue(3.14), + Target: NewEnvFloatValue(3.14), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvFloatValue(3.14), + Target: NewEnvFloatValue(2.718), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvFloatVariable("MY_VAR"), + Target: NewEnvFloatVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvFloatVariable("VAR1"), + Target: NewEnvFloatVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvFloat("MY_VAR", 3.14), + Target: NewEnvFloat("MY_VAR", 3.14), + Expected: true, + }, + { + Name: "value_vs_variable", + Input: NewEnvFloatValue(3.14), + Target: NewEnvFloatVariable("MY_VAR"), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} diff --git a/map.go b/map.go index a1b20eb..638d1f5 100644 --- a/map.go +++ b/map.go @@ -42,13 +42,14 @@ func (ev EnvMapString) IsZero() bool { // Equal checks if this instance equals the target value. func (ev EnvMapString) Equal(target EnvMapString) bool { - isSameValue := (ev.Value == nil && target.Value == nil) || - (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) - isSameEnv := (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) + if !isSameEnv { + return false + } - return isSameValue && isSameEnv + return (ev.Value == nil && target.Value == nil) || + (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) } // UnmarshalJSON implements json.Unmarshaler. @@ -131,13 +132,14 @@ func (ev EnvMapInt) IsZero() bool { // Equal checks if this instance equals the target value. func (ev EnvMapInt) Equal(target EnvMapInt) bool { - isSameValue := (ev.Value == nil && target.Value == nil) || - (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) - isSameEnv := (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) + if !isSameEnv { + return false + } - return isSameValue && isSameEnv + return (ev.Value == nil && target.Value == nil) || + (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) } // UnmarshalJSON implements json.Unmarshaler. @@ -220,13 +222,14 @@ func (ev EnvMapFloat) IsZero() bool { // Equal checks if this instance equals the target value. func (ev EnvMapFloat) Equal(target EnvMapFloat) bool { - isSameValue := (ev.Value == nil && target.Value == nil) || - (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) - isSameEnv := (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) + if !isSameEnv { + return false + } - return isSameValue && isSameEnv + return (ev.Value == nil && target.Value == nil) || + (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) } // UnmarshalJSON implements json.Unmarshaler. @@ -309,13 +312,14 @@ func (ev EnvMapBool) IsZero() bool { // Equal checks if this instance equals the target value. func (ev EnvMapBool) Equal(target EnvMapBool) bool { - isSameValue := (ev.Value == nil && target.Value == nil) || - (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) - isSameEnv := (ev.Variable == nil && target.Variable == nil) || (ev.Variable != nil && target.Variable != nil && *ev.Variable == *target.Variable) + if !isSameEnv { + return false + } - return isSameValue && isSameEnv + return (ev.Value == nil && target.Value == nil) || + (ev.Value != nil && target.Value != nil && maps.Equal(ev.Value, target.Value)) } // UnmarshalJSON implements json.Unmarshaler. diff --git a/map_equal_test.go b/map_equal_test.go deleted file mode 100644 index 22f153a..0000000 --- a/map_equal_test.go +++ /dev/null @@ -1,267 +0,0 @@ -package goenvconf - -import ( - "testing" -) - -func TestEnvMapString_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvMapString - Target EnvMapString - Expected bool - }{ - { - Name: "both_nil", - Input: EnvMapString{}, - Target: EnvMapString{}, - Expected: true, - }, - { - Name: "same_literal_values", - Input: NewEnvMapStringValue(map[string]string{"key1": "value1", "key2": "value2"}), - Target: NewEnvMapStringValue(map[string]string{"key1": "value1", "key2": "value2"}), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvMapStringValue(map[string]string{"key1": "value1"}), - Target: NewEnvMapStringValue(map[string]string{"key2": "value2"}), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvMapStringVariable("MY_VAR"), - Target: NewEnvMapStringVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvMapStringVariable("VAR1"), - Target: NewEnvMapStringVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvMapString("MY_VAR", map[string]string{"key": "value"}), - Target: NewEnvMapString("MY_VAR", map[string]string{"key": "value"}), - Expected: true, - }, - { - Name: "value_vs_variable", - Input: NewEnvMapStringValue(map[string]string{"key": "value"}), - Target: NewEnvMapStringVariable("MY_VAR"), - Expected: false, - }, - { - Name: "nil_vs_empty_map", - Input: EnvMapString{Value: nil}, - Target: NewEnvMapStringValue(map[string]string{}), - Expected: false, - }, - { - Name: "both_empty_maps", - Input: NewEnvMapStringValue(map[string]string{}), - Target: NewEnvMapStringValue(map[string]string{}), - Expected: true, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} - -func TestEnvMapInt_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvMapInt - Target EnvMapInt - Expected bool - }{ - { - Name: "both_nil", - Input: EnvMapInt{}, - Target: EnvMapInt{}, - Expected: true, - }, - { - Name: "same_literal_values", - Input: NewEnvMapIntValue(map[string]int64{"key1": 1, "key2": 2}), - Target: NewEnvMapIntValue(map[string]int64{"key1": 1, "key2": 2}), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvMapIntValue(map[string]int64{"key1": 1}), - Target: NewEnvMapIntValue(map[string]int64{"key2": 2}), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvMapIntVariable("MY_VAR"), - Target: NewEnvMapIntVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvMapIntVariable("VAR1"), - Target: NewEnvMapIntVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvMapInt("MY_VAR", map[string]int64{"key": 42}), - Target: NewEnvMapInt("MY_VAR", map[string]int64{"key": 42}), - Expected: true, - }, - { - Name: "value_vs_variable", - Input: NewEnvMapIntValue(map[string]int64{"key": 42}), - Target: NewEnvMapIntVariable("MY_VAR"), - Expected: false, - }, - { - Name: "nil_vs_empty_map", - Input: EnvMapInt{Value: nil}, - Target: NewEnvMapIntValue(map[string]int64{}), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} - -func TestEnvMapFloat_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvMapFloat - Target EnvMapFloat - Expected bool - }{ - { - Name: "both_nil", - Input: EnvMapFloat{}, - Target: EnvMapFloat{}, - Expected: true, - }, - { - Name: "same_literal_values", - Input: NewEnvMapFloatValue(map[string]float64{"key1": 3.14, "key2": 2.718}), - Target: NewEnvMapFloatValue(map[string]float64{"key1": 3.14, "key2": 2.718}), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvMapFloatValue(map[string]float64{"key1": 3.14}), - Target: NewEnvMapFloatValue(map[string]float64{"key2": 2.718}), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvMapFloatVariable("MY_VAR"), - Target: NewEnvMapFloatVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvMapFloatVariable("VAR1"), - Target: NewEnvMapFloatVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvMapFloat("MY_VAR", map[string]float64{"key": 3.14}), - Target: NewEnvMapFloat("MY_VAR", map[string]float64{"key": 3.14}), - Expected: true, - }, - { - Name: "value_vs_variable", - Input: NewEnvMapFloatValue(map[string]float64{"key": 3.14}), - Target: NewEnvMapFloatVariable("MY_VAR"), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} - -func TestEnvMapBool_Equal(t *testing.T) { - testCases := []struct { - Name string - Input EnvMapBool - Target EnvMapBool - Expected bool - }{ - { - Name: "both_nil", - Input: EnvMapBool{}, - Target: EnvMapBool{}, - Expected: true, - }, - { - Name: "same_literal_values", - Input: NewEnvMapBoolValue(map[string]bool{"key1": true, "key2": false}), - Target: NewEnvMapBoolValue(map[string]bool{"key1": true, "key2": false}), - Expected: true, - }, - { - Name: "different_literal_values", - Input: NewEnvMapBoolValue(map[string]bool{"key1": true}), - Target: NewEnvMapBoolValue(map[string]bool{"key2": false}), - Expected: false, - }, - { - Name: "same_variable_names", - Input: NewEnvMapBoolVariable("MY_VAR"), - Target: NewEnvMapBoolVariable("MY_VAR"), - Expected: true, - }, - { - Name: "different_variable_names", - Input: NewEnvMapBoolVariable("VAR1"), - Target: NewEnvMapBoolVariable("VAR2"), - Expected: false, - }, - { - Name: "same_value_and_variable", - Input: NewEnvMapBool("MY_VAR", map[string]bool{"key": true}), - Target: NewEnvMapBool("MY_VAR", map[string]bool{"key": true}), - Expected: true, - }, - { - Name: "value_vs_variable", - Input: NewEnvMapBoolValue(map[string]bool{"key": true}), - Target: NewEnvMapBoolVariable("MY_VAR"), - Expected: false, - }, - } - - for _, tc := range testCases { - t.Run(tc.Name, func(t *testing.T) { - result := tc.Input.Equal(tc.Target) - if result != tc.Expected { - t.Errorf("Expected %v, got %v", tc.Expected, result) - } - }) - } -} diff --git a/map_test.go b/map_test.go index 3ad74fd..a73ec1b 100644 --- a/map_test.go +++ b/map_test.go @@ -508,3 +508,265 @@ func TestEnvMapString(t *testing.T) { }, result) }) } + +func TestEnvMapString_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvMapString + Target EnvMapString + Expected bool + }{ + { + Name: "both_nil", + Input: EnvMapString{}, + Target: EnvMapString{}, + Expected: true, + }, + { + Name: "same_literal_values", + Input: NewEnvMapStringValue(map[string]string{"key1": "value1", "key2": "value2"}), + Target: NewEnvMapStringValue(map[string]string{"key1": "value1", "key2": "value2"}), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvMapStringValue(map[string]string{"key1": "value1"}), + Target: NewEnvMapStringValue(map[string]string{"key2": "value2"}), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvMapStringVariable("MY_VAR"), + Target: NewEnvMapStringVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvMapStringVariable("VAR1"), + Target: NewEnvMapStringVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvMapString("MY_VAR", map[string]string{"key": "value"}), + Target: NewEnvMapString("MY_VAR", map[string]string{"key": "value"}), + Expected: true, + }, + { + Name: "value_vs_variable", + Input: NewEnvMapStringValue(map[string]string{"key": "value"}), + Target: NewEnvMapStringVariable("MY_VAR"), + Expected: false, + }, + { + Name: "nil_vs_empty_map", + Input: EnvMapString{Value: nil}, + Target: NewEnvMapStringValue(map[string]string{}), + Expected: false, + }, + { + Name: "both_empty_maps", + Input: NewEnvMapStringValue(map[string]string{}), + Target: NewEnvMapStringValue(map[string]string{}), + Expected: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} + +func TestEnvMapInt_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvMapInt + Target EnvMapInt + Expected bool + }{ + { + Name: "both_nil", + Input: EnvMapInt{}, + Target: EnvMapInt{}, + Expected: true, + }, + { + Name: "same_literal_values", + Input: NewEnvMapIntValue(map[string]int64{"key1": 1, "key2": 2}), + Target: NewEnvMapIntValue(map[string]int64{"key1": 1, "key2": 2}), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvMapIntValue(map[string]int64{"key1": 1}), + Target: NewEnvMapIntValue(map[string]int64{"key2": 2}), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvMapIntVariable("MY_VAR"), + Target: NewEnvMapIntVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvMapIntVariable("VAR1"), + Target: NewEnvMapIntVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvMapInt("MY_VAR", map[string]int64{"key": 42}), + Target: NewEnvMapInt("MY_VAR", map[string]int64{"key": 42}), + Expected: true, + }, + { + Name: "value_vs_variable", + Input: NewEnvMapIntValue(map[string]int64{"key": 42}), + Target: NewEnvMapIntVariable("MY_VAR"), + Expected: false, + }, + { + Name: "nil_vs_empty_map", + Input: EnvMapInt{Value: nil}, + Target: NewEnvMapIntValue(map[string]int64{}), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} + +func TestEnvMapFloat_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvMapFloat + Target EnvMapFloat + Expected bool + }{ + { + Name: "both_nil", + Input: EnvMapFloat{}, + Target: EnvMapFloat{}, + Expected: true, + }, + { + Name: "same_literal_values", + Input: NewEnvMapFloatValue(map[string]float64{"key1": 3.14, "key2": 2.718}), + Target: NewEnvMapFloatValue(map[string]float64{"key1": 3.14, "key2": 2.718}), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvMapFloatValue(map[string]float64{"key1": 3.14}), + Target: NewEnvMapFloatValue(map[string]float64{"key2": 2.718}), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvMapFloatVariable("MY_VAR"), + Target: NewEnvMapFloatVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvMapFloatVariable("VAR1"), + Target: NewEnvMapFloatVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvMapFloat("MY_VAR", map[string]float64{"key": 3.14}), + Target: NewEnvMapFloat("MY_VAR", map[string]float64{"key": 3.14}), + Expected: true, + }, + { + Name: "value_vs_variable", + Input: NewEnvMapFloatValue(map[string]float64{"key": 3.14}), + Target: NewEnvMapFloatVariable("MY_VAR"), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +} + +func TestEnvMapBool_Equal(t *testing.T) { + testCases := []struct { + Name string + Input EnvMapBool + Target EnvMapBool + Expected bool + }{ + { + Name: "both_nil", + Input: EnvMapBool{}, + Target: EnvMapBool{}, + Expected: true, + }, + { + Name: "same_literal_values", + Input: NewEnvMapBoolValue(map[string]bool{"key1": true, "key2": false}), + Target: NewEnvMapBoolValue(map[string]bool{"key1": true, "key2": false}), + Expected: true, + }, + { + Name: "different_literal_values", + Input: NewEnvMapBoolValue(map[string]bool{"key1": true}), + Target: NewEnvMapBoolValue(map[string]bool{"key2": false}), + Expected: false, + }, + { + Name: "same_variable_names", + Input: NewEnvMapBoolVariable("MY_VAR"), + Target: NewEnvMapBoolVariable("MY_VAR"), + Expected: true, + }, + { + Name: "different_variable_names", + Input: NewEnvMapBoolVariable("VAR1"), + Target: NewEnvMapBoolVariable("VAR2"), + Expected: false, + }, + { + Name: "same_value_and_variable", + Input: NewEnvMapBool("MY_VAR", map[string]bool{"key": true}), + Target: NewEnvMapBool("MY_VAR", map[string]bool{"key": true}), + Expected: true, + }, + { + Name: "value_vs_variable", + Input: NewEnvMapBoolValue(map[string]bool{"key": true}), + Target: NewEnvMapBoolVariable("MY_VAR"), + Expected: false, + }, + } + + for _, tc := range testCases { + t.Run(tc.Name, func(t *testing.T) { + result := tc.Input.Equal(tc.Target) + if result != tc.Expected { + t.Errorf("Expected %v, got %v", tc.Expected, result) + } + }) + } +}