...

pkg2/heroscript/paramsparser/paramsparser_test.go

@@ -0,0 +1,226 @@
+package paramsparser
+
+import (
+	"testing"
+)
+
+func TestParamsParserBasic(t *testing.T) {
+	input := "name:'myname' host:'localhost' port:25 secure:1 reset:1"
+	parser := New()
+	err := parser.ParseString(input)
+	if err != nil {
+		t.Fatalf("Failed to parse input: %v", err)
+	}
+
+	tests := []struct {
+		name     string
+		key      string
+		expected string
+	}{
+		{"string value", "name", "myname"},
+		{"another string value", "host", "localhost"},
+		{"numeric value", "port", "25"},
+		{"boolean-like value", "secure", "1"},
+		{"another boolean-like value", "reset", "1"},
+		{"non-existent key", "nonexistent", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := parser.Get(tt.key); got != tt.expected {
+				t.Errorf("ParamsParser.Get(%q) = %q, want %q", tt.key, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestParamsParserMultiline(t *testing.T) {
+	input := "name:'myname' description:'\n\t\ta description can be multiline\n\n\t\tlike this\n'"
+	parser := New()
+	err := parser.Parse(input)
+	if err != nil {
+		t.Fatalf("Failed to parse input: %v", err)
+	}
+
+	// Check the name parameter
+	if got := parser.Get("name"); got != "myname" {
+		t.Errorf("ParamsParser.Get(\"name\") = %q, want %q", got, "myname")
+	}
+
+	// Check the multiline description
+	expectedDesc := "\n\t\ta description can be multiline\n\n\t\tlike this\n"
+	if got := parser.Get("description"); got != expectedDesc {
+		t.Errorf("ParamsParser.Get(\"description\") = %q, want %q", got, expectedDesc)
+	}
+}
+
+func TestParamsParserDefaults(t *testing.T) {
+	parser := New()
+	parser.SetDefault("key1", "default1")
+	parser.SetDefaults(map[string]string{
+		"key2": "default2",
+		"key3": "default3",
+	})
+
+	// Override one default
+	parser.Set("key2", "override")
+
+	tests := []struct {
+		name     string
+		key      string
+		expected string
+	}{
+		{"default value", "key1", "default1"},
+		{"overridden value", "key2", "override"},
+		{"another default", "key3", "default3"},
+		{"non-existent key", "key4", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := parser.Get(tt.key); got != tt.expected {
+				t.Errorf("ParamsParser.Get(%q) = %q, want %q", tt.key, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestParamsParserTypes(t *testing.T) {
+	parser := New()
+	parser.Set("int", "123")
+	parser.Set("float", "3.14")
+	parser.Set("bool_true", "true")
+	parser.Set("bool_yes", "yes")
+	parser.Set("bool_1", "1")
+	parser.Set("bool_false", "false")
+	parser.Set("invalid_int", "not_an_int")
+	parser.Set("invalid_float", "not_a_float")
+
+	t.Run("GetInt", func(t *testing.T) {
+		if val, err := parser.GetInt("int"); err != nil || val != 123 {
+			t.Errorf("GetInt(\"int\") = %d, %v, want 123, nil", val, err)
+		}
+		if val, err := parser.GetInt("invalid_int"); err == nil {
+			t.Errorf("GetInt(\"invalid_int\") = %d, %v, want error", val, err)
+		}
+		if val, err := parser.GetInt("nonexistent"); err == nil {
+			t.Errorf("GetInt(\"nonexistent\") = %d, %v, want error", val, err)
+		}
+	})
+
+	t.Run("GetIntDefault", func(t *testing.T) {
+		if val := parser.GetIntDefault("int", 0); val != 123 {
+			t.Errorf("GetIntDefault(\"int\", 0) = %d, want 123", val)
+		}
+		if val := parser.GetIntDefault("invalid_int", 42); val != 42 {
+			t.Errorf("GetIntDefault(\"invalid_int\", 42) = %d, want 42", val)
+		}
+		if val := parser.GetIntDefault("nonexistent", 42); val != 42 {
+			t.Errorf("GetIntDefault(\"nonexistent\", 42) = %d, want 42", val)
+		}
+	})
+
+	t.Run("GetFloat", func(t *testing.T) {
+		if val, err := parser.GetFloat("float"); err != nil || val != 3.14 {
+			t.Errorf("GetFloat(\"float\") = %f, %v, want 3.14, nil", val, err)
+		}
+		if val, err := parser.GetFloat("invalid_float"); err == nil {
+			t.Errorf("GetFloat(\"invalid_float\") = %f, %v, want error", val, err)
+		}
+		if val, err := parser.GetFloat("nonexistent"); err == nil {
+			t.Errorf("GetFloat(\"nonexistent\") = %f, %v, want error", val, err)
+		}
+	})
+
+	t.Run("GetFloatDefault", func(t *testing.T) {
+		if val := parser.GetFloatDefault("float", 0.0); val != 3.14 {
+			t.Errorf("GetFloatDefault(\"float\", 0.0) = %f, want 3.14", val)
+		}
+		if val := parser.GetFloatDefault("invalid_float", 2.71); val != 2.71 {
+			t.Errorf("GetFloatDefault(\"invalid_float\", 2.71) = %f, want 2.71", val)
+		}
+		if val := parser.GetFloatDefault("nonexistent", 2.71); val != 2.71 {
+			t.Errorf("GetFloatDefault(\"nonexistent\", 2.71) = %f, want 2.71", val)
+		}
+	})
+
+	t.Run("GetBool", func(t *testing.T) {
+		if val := parser.GetBool("bool_true"); !val {
+			t.Errorf("GetBool(\"bool_true\") = %v, want true", val)
+		}
+		if val := parser.GetBool("bool_yes"); !val {
+			t.Errorf("GetBool(\"bool_yes\") = %v, want true", val)
+		}
+		if val := parser.GetBool("bool_1"); !val {
+			t.Errorf("GetBool(\"bool_1\") = %v, want true", val)
+		}
+		if val := parser.GetBool("bool_false"); val {
+			t.Errorf("GetBool(\"bool_false\") = %v, want false", val)
+		}
+		if val := parser.GetBool("nonexistent"); val {
+			t.Errorf("GetBool(\"nonexistent\") = %v, want false", val)
+		}
+	})
+
+	t.Run("GetBoolDefault", func(t *testing.T) {
+		if val := parser.GetBoolDefault("bool_true", false); !val {
+			t.Errorf("GetBoolDefault(\"bool_true\", false) = %v, want true", val)
+		}
+		if val := parser.GetBoolDefault("nonexistent", true); !val {
+			t.Errorf("GetBoolDefault(\"nonexistent\", true) = %v, want true", val)
+		}
+	})
+}
+
+func TestParamsParserGetAll(t *testing.T) {
+	parser := New()
+	parser.SetDefault("key1", "default1")
+	parser.SetDefault("key2", "default2")
+	parser.Set("key2", "override")
+	parser.Set("key3", "value3")
+
+	all := parser.GetAll()
+	
+	expected := map[string]string{
+		"key1": "default1",
+		"key2": "override",
+		"key3": "value3",
+	}
+
+	if len(all) != len(expected) {
+		t.Errorf("GetAll() returned map with %d entries, want %d", len(all), len(expected))
+	}
+
+	for k, v := range expected {
+		if all[k] != v {
+			t.Errorf("GetAll()[%q] = %q, want %q", k, all[k], v)
+		}
+	}
+}
+
+func TestParamsParserMustGet(t *testing.T) {
+	parser := New()
+	parser.Set("key", "value")
+	parser.Set("int", "123")
+	parser.Set("float", "3.14")
+
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("MustGet on non-existent key did not panic")
+		}
+	}()
+
+	// These should not panic
+	if val := parser.MustGet("key"); val != "value" {
+		t.Errorf("MustGet(\"key\") = %q, want \"value\"", val)
+	}
+	if val := parser.MustGetInt("int"); val != 123 {
+		t.Errorf("MustGetInt(\"int\") = %d, want 123", val)
+	}
+	if val := parser.MustGetFloat("float"); val != 3.14 {
+		t.Errorf("MustGetFloat(\"float\") = %f, want 3.14", val)
+	}
+
+	// This should panic
+	parser.MustGet("nonexistent")
+}