Fin/tests/read_test.go

package fin_test

import (
	"reflect"
	"strings"
	"testing"

	fin "git.sharkk.net/Sharkk/Fin"
)

func TestBasicKeyValuePairs(t *testing.T) {
	input := `
	boolTrue true
	boolFalse false
	integer 42
	negativeInt -10
	floatValue 3.14
	negativeFloat -2.5
	stringValue "hello world"
	`
	config, err := fin.Load(strings.NewReader(input))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify boolean values
	boolTrue, err := config.GetBool("boolTrue")
	if err != nil || boolTrue != true {
		t.Errorf("expected boolTrue=true, got %v, err: %v", boolTrue, err)
	}

	boolFalse, err := config.GetBool("boolFalse")
	if err != nil || boolFalse != false {
		t.Errorf("expected boolFalse=false, got %v, err: %v", boolFalse, err)
	}

	// Verify integer values
	integer, err := config.GetInt("integer")
	if err != nil || integer != 42 {
		t.Errorf("expected integer=42, got %v, err: %v", integer, err)
	}

	negativeInt, err := config.GetInt("negativeInt")
	if err != nil || negativeInt != -10 {
		t.Errorf("expected negativeInt=-10, got %v, err: %v", negativeInt, err)
	}

	// Verify float values
	floatValue, err := config.GetFloat("floatValue")
	if err != nil || floatValue != 3.14 {
		t.Errorf("expected floatValue=3.14, got %v, err: %v", floatValue, err)
	}

	negativeFloat, err := config.GetFloat("negativeFloat")
	if err != nil || negativeFloat != -2.5 {
		t.Errorf("expected negativeFloat=-2.5, got %v, err: %v", negativeFloat, err)
	}

	// Verify string values
	stringValue, err := config.GetString("stringValue")
	if err != nil || stringValue != "hello world" {
		t.Errorf("expected stringValue=\"hello world\", got %v, err: %v", stringValue, err)
	}

	// Verify missing key handling
	_, err = config.GetString("nonExistentKey")
	if err == nil {
		t.Errorf("expected error for non-existent key, got nil")
	}

	// Test GetOr with defaults
	defaultBool := config.GetOr("nonExistentKey", true).(bool)
	if defaultBool != true {
		t.Errorf("expected GetOr to return default true, got %v", defaultBool)
	}

	defaultString := config.GetOr("nonExistentKey", "default").(string)
	if defaultString != "default" {
		t.Errorf("expected GetOr to return 'default', got %v", defaultString)
	}
}

func TestComments(t *testing.T) {
	input := `
	-- This is a line comment
	key1 "value1"

	--[[ This is a
	     block comment spanning
	     multiple lines ]]
	key2 "value2"

	settings {
		-- Comment inside a map
		timeout 30
		--[[ Another block comment ]]
		retries 3
	}
	`

	config, err := fin.Load(strings.NewReader(input))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify that comments are properly ignored and values are parsed
	val1, err := config.GetString("key1")
	if err != nil || val1 != "value1" {
		t.Errorf("expected key1=\"value1\", got %v, err: %v", val1, err)
	}

	val2, err := config.GetString("key2")
	if err != nil || val2 != "value2" {
		t.Errorf("expected key2=\"value2\", got %v, err: %v", val2, err)
	}

	// Verify nested values after comments
	timeout, err := config.GetInt("settings.timeout")
	if err != nil || timeout != 30 {
		t.Errorf("expected settings.timeout=30, got %v, err: %v", timeout, err)
	}

	retries, err := config.GetInt("settings.retries")
	if err != nil || retries != 3 {
		t.Errorf("expected settings.retries=3, got %v, err: %v", retries, err)
	}
}

func TestArrays(t *testing.T) {
	input := `
	-- Simple array
	fruits {
		"apple"
		"banana"
		"cherry"
	}

	-- Mixed types array
	mixed {
		"string"
		42
		true
		3.14
	}
	`

	config, err := fin.Load(strings.NewReader(input))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify simple array
	fruits, err := config.GetArray("fruits")
	if err != nil {
		t.Fatalf("failed to get fruits array: %v", err)
	}

	expectedFruits := []any{"apple", "banana", "cherry"}
	if !reflect.DeepEqual(fruits, expectedFruits) {
		t.Errorf("expected fruits=%v, got %v", expectedFruits, fruits)
	}

	// Verify array accessed with index notation
	apple, err := config.GetString("fruits.0")
	if err != nil || apple != "apple" {
		t.Errorf("expected fruits.0=\"apple\", got %v, err: %v", apple, err)
	}

	// Verify mixed types array
	mixed, err := config.GetArray("mixed")
	if err != nil {
		t.Fatalf("failed to get mixed array: %v", err)
	}

	if len(mixed) != 4 {
		t.Errorf("expected 4 items in mixed array, got %d", len(mixed))
	}

	// Check types in mixed array
	stringVal, err := config.GetString("mixed.0")
	if err != nil || stringVal != "string" {
		t.Errorf("expected mixed.0=\"string\", got %v, err: %v", stringVal, err)
	}

	intVal, err := config.GetInt("mixed.1")
	if err != nil || intVal != 42 {
		t.Errorf("expected mixed.1=42, got %v, err: %v", intVal, err)
	}

	boolVal, err := config.GetBool("mixed.2")
	if err != nil || boolVal != true {
		t.Errorf("expected mixed.2=true, got %v, err: %v", boolVal, err)
	}

	floatVal, err := config.GetFloat("mixed.3")
	if err != nil || floatVal != 3.14 {
		t.Errorf("expected mixed.3=3.14, got %v, err: %v", floatVal, err)
	}
}

func TestMaps(t *testing.T) {
	input := `
	-- Simple map
	server {
		host "localhost"
		port 8080
	}

	-- Nested maps
	application {
		name "MyApp"
		version "1.0.0"
		settings {
			theme "dark"
			notifications true
			logging {
				level "info"
				file "app.log"
			}
		}
	}
	`

	config, err := fin.Load(strings.NewReader(input))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify simple map
	serverMap, err := config.GetMap("server")
	if err != nil {
		t.Fatalf("failed to get server map: %v", err)
	}

	if len(serverMap) != 2 {
		t.Errorf("expected 2 items in server map, got %d", len(serverMap))
	}

	// Verify dot notation access
	host, err := config.GetString("server.host")
	if err != nil || host != "localhost" {
		t.Errorf("expected server.host=\"localhost\", got %v, err: %v", host, err)
	}

	port, err := config.GetInt("server.port")
	if err != nil || port != 8080 {
		t.Errorf("expected server.port=8080, got %v, err: %v", port, err)
	}

	// Verify deeply nested maps
	appName, err := config.GetString("application.name")
	if err != nil || appName != "MyApp" {
		t.Errorf("expected application.name=\"MyApp\", got %v, err: %v", appName, err)
	}

	theme, err := config.GetString("application.settings.theme")
	if err != nil || theme != "dark" {
		t.Errorf("expected application.settings.theme=\"dark\", got %v, err: %v", theme, err)
	}

	logLevel, err := config.GetString("application.settings.logging.level")
	if err != nil || logLevel != "info" {
		t.Errorf("expected application.settings.logging.level=\"info\", got %v, err: %v", logLevel, err)
	}

	// Test non-existent nested paths
	_, err = config.GetString("application.settings.nonexistent")
	if err == nil {
		t.Errorf("expected error for non-existent nested key, got nil")
	}
}