env_test.go

package struct2pflag_test

import (
	"errors"
	"testing"
	"time"

	"github.com/goark/struct2pflag"
)

type envNested struct {
	Name string `env:"APP_NAME"`
}

type envConfig struct {
	Enabled bool          `env:"ENABLED"`
	Count   int           `env:"COUNT"`
	Rate    float64       `env:"RATE"`
	Wait    time.Duration `env:"WAIT"`
	Label   string        `env:"LABEL"`
	Nested  envNested
}

func TestBindEnvBasic(t *testing.T) {
	t.Setenv("ENABLED", "true")
	t.Setenv("COUNT", "12")
	t.Setenv("RATE", "1.25")
	t.Setenv("WAIT", "3s")
	t.Setenv("LABEL", "alpha")
	t.Setenv("APP_NAME", "demo")

	cfg := envConfig{}
	if err := struct2pflag.BindEnv(&cfg); err != nil {
		t.Fatalf("BindEnv() error = %v", err)
	}

	if cfg.Enabled != true {
		t.Fatalf("Enabled = %v, want true", cfg.Enabled)
	}
	if cfg.Count != 12 {
		t.Fatalf("Count = %v, want 12", cfg.Count)
	}
	if cfg.Rate != 1.25 {
		t.Fatalf("Rate = %v, want 1.25", cfg.Rate)
	}
	if cfg.Wait != 3*time.Second {
		t.Fatalf("Wait = %v, want 3s", cfg.Wait)
	}
	if cfg.Label != "alpha" {
		t.Fatalf("Label = %q, want alpha", cfg.Label)
	}
	if cfg.Nested.Name != "demo" {
		t.Fatalf("Nested.Name = %q, want demo", cfg.Nested.Name)
	}
}

func TestBindEnvUnsetPreservesDefaults(t *testing.T) {
	cfg := envConfig{
		Enabled: true,
		Count:   5,
		Rate:    2.0,
		Wait:    time.Minute,
		Label:   "default",
	}
	if err := struct2pflag.BindEnv(&cfg); err != nil {
		t.Fatalf("BindEnv() error = %v", err)
	}
	if cfg.Enabled != true || cfg.Count != 5 || cfg.Rate != 2.0 || cfg.Wait != time.Minute || cfg.Label != "default" {
		t.Fatalf("defaults were unexpectedly changed: %#v", cfg)
	}
}

func TestBindEnvOptions(t *testing.T) {
	t.Setenv("APP_PORT", "8080")
	t.Setenv("APP_DEBUG", "true")
	type cfg struct {
		Port  int  `conf:"PORT"`
		Debug bool `conf:"DEBUG"`
	}

	c := cfg{}
	err := struct2pflag.BindEnv(&c,
		struct2pflag.WithEnvTag("conf"),
		struct2pflag.WithEnvPrefix("APP_"),
	)
	if err != nil {
		t.Fatalf("BindEnv() error = %v", err)
	}
	if c.Port != 8080 || c.Debug != true {
		t.Fatalf("BindEnv() applied unexpected values: %#v", c)
	}
}

func TestBindEnvParseErrors(t *testing.T) {
	type cfg struct {
		N int           `env:"N"`
		B bool          `env:"B"`
		D time.Duration `env:"D"`
	}

	t.Run("int", func(t *testing.T) {
		t.Setenv("N", "oops")
		c := cfg{}
		err := struct2pflag.BindEnv(&c)
		if err == nil || !errors.Is(err, struct2pflag.ErrEnvParse) {
			t.Fatalf("BindEnv() error = %v, want ErrEnvParse", err)
		}
	})

	t.Run("bool", func(t *testing.T) {
		t.Setenv("B", "oops")
		c := cfg{}
		err := struct2pflag.BindEnv(&c)
		if err == nil || !errors.Is(err, struct2pflag.ErrEnvParse) {
			t.Fatalf("BindEnv() error = %v, want ErrEnvParse", err)
		}
	})

	t.Run("duration", func(t *testing.T) {
		t.Setenv("D", "oops")
		c := cfg{}
		err := struct2pflag.BindEnv(&c)
		if err == nil || !errors.Is(err, struct2pflag.ErrEnvParse) {
			t.Fatalf("BindEnv() error = %v, want ErrEnvParse", err)
		}
	})
}

func TestBindEnvInvalidTarget(t *testing.T) {
	type cfg struct {
		Value int `env:"VALUE"`
	}
	var c cfg
	err := struct2pflag.BindEnv(c)
	if err == nil || !errors.Is(err, struct2pflag.ErrInvalidEnvTarget) {
		t.Fatalf("BindEnv() error = %v, want ErrInvalidEnvTarget", err)
	}
}

func TestBindEnvStrictUnsupportedType(t *testing.T) {
	t.Setenv("ITEMS", "a,b,c")
	type cfg struct {
		Items []string `env:"ITEMS"`
	}

	c1 := cfg{}
	if err := struct2pflag.BindEnv(&c1); err != nil {
		t.Fatalf("BindEnv() strict=false error = %v", err)
	}

	c2 := cfg{}
	err := struct2pflag.BindEnv(&c2, struct2pflag.WithStrict(true))
	if err == nil || !errors.Is(err, struct2pflag.ErrUnsupportedEnvType) {
		t.Fatalf("BindEnv() strict=true error = %v, want ErrUnsupportedEnvType", err)
	}
}