kvfile_test.go

package kvfile

import (
	"bufio"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"gotest.tools/v3/assert"
	is "gotest.tools/v3/assert/cmp"
)

// Test Parse for a non existent file.
func TestParseNonExistentFile(t *testing.T) {
	_, err := Parse("no_such_file", nil)
	assert.Check(t, is.ErrorType(err, os.IsNotExist))
}

// Test Parse from a file with a lookup function.
func TestParseWithLookup(t *testing.T) {
	content := `# comment=
VAR=VAR_VALUE
EMPTY_VAR=
UNDEFINED_VAR
DEFINED_VAR
`
	vars := map[string]string{
		"DEFINED_VAR": "defined-value",
	}
	lookupFn := func(name string) (string, bool) {
		v, ok := vars[name]
		return v, ok
	}

	fileName := filepath.Join(t.TempDir(), "envfile")
	err := os.WriteFile(fileName, []byte(content), 0o644)
	assert.NilError(t, err)

	variables, err := Parse(fileName, lookupFn)
	assert.NilError(t, err)

	expectedLines := []string{"VAR=VAR_VALUE", "EMPTY_VAR=", "DEFINED_VAR=defined-value"}
	assert.Check(t, is.DeepEqual(variables, expectedLines))
}

// Test ParseEnvFile for a file with a few well formatted lines
func TestParseFromReaderGoodFile(t *testing.T) {
	content := `foo=bar
    baz=quux
# comment

_foobar=foobaz
with.dots=working
and_underscore=working too
`
	// Adding a newline + a line with pure whitespace.
	// This is being done like this instead of the block above
	// because it's common for editors to trim trailing whitespace
	// from lines, which becomes annoying since that's the
	// exact thing we need to test.
	content += "\n    \t  "

	lines, err := ParseFromReader(strings.NewReader(content), nil)
	assert.NilError(t, err)

	expectedLines := []string{
		"foo=bar",
		"baz=quux",
		"_foobar=foobaz",
		"with.dots=working",
		"and_underscore=working too",
	}

	assert.Check(t, is.DeepEqual(lines, expectedLines))
}

// Test ParseFromReader for an empty file
func TestParseFromReaderEmptyFile(t *testing.T) {
	lines, err := ParseFromReader(strings.NewReader(""), nil)
	assert.NilError(t, err)
	assert.Check(t, is.Len(lines, 0))
}

// Test ParseFromReader for a badly formatted file
func TestParseFromReaderBadlyFormattedFile(t *testing.T) {
	content := `foo=bar
    f   =quux
`
	_, err := ParseFromReader(strings.NewReader(content), nil)
	const expectedMessage = "variable 'f   ' contains whitespaces"
	assert.Check(t, is.ErrorContains(err, expectedMessage))
}

// Test ParseFromReader for a file with a line exceeding bufio.MaxScanTokenSize
func TestParseFromReaderLineTooLongFile(t *testing.T) {
	content := "foo=" + strings.Repeat("a", bufio.MaxScanTokenSize+42)

	_, err := ParseFromReader(strings.NewReader(content), nil)
	const expectedMessage = "bufio.Scanner: token too long"
	assert.Check(t, is.ErrorContains(err, expectedMessage))
}

// ParseEnvFile with a random file, pass through
func TestParseFromReaderRandomFile(t *testing.T) {
	content := `first line
another invalid line`

	_, err := ParseFromReader(strings.NewReader(content), nil)
	const expectedMessage = "variable 'first line' contains whitespaces"
	assert.Check(t, is.ErrorContains(err, expectedMessage))
}

// Test ParseFromReader with a lookup function.
func TestParseFromReaderWithLookup(t *testing.T) {
	content := `# comment=
VAR=VAR_VALUE
EMPTY_VAR=
UNDEFINED_VAR
DEFINED_VAR
`
	vars := map[string]string{
		"DEFINED_VAR": "defined-value",
	}
	lookupFn := func(name string) (string, bool) {
		v, ok := vars[name]
		return v, ok
	}

	variables, err := ParseFromReader(strings.NewReader(content), lookupFn)
	assert.NilError(t, err)

	expectedLines := []string{"VAR=VAR_VALUE", "EMPTY_VAR=", "DEFINED_VAR=defined-value"}
	assert.Check(t, is.DeepEqual(variables, expectedLines))
}

// Test ParseFromReader with empty variable name
func TestParseFromReaderWithNoName(t *testing.T) {
	content := `# comment=
=blank variable names are an error case
`
	_, err := ParseFromReader(strings.NewReader(content), nil)
	const expectedMessage = "no variable name on line '=blank variable names are an error case'"
	assert.Check(t, is.ErrorContains(err, expectedMessage))
}

// Test trimQuotes helper function
func TestTrimQuotes(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{name: "double quotes", input: `"bar"`, expected: "bar"},
		{name: "single quotes", input: "'bar'", expected: "bar"},
		{name: "no quotes", input: "bar", expected: "bar"},
		{name: "empty string", input: "", expected: ""},
		{name: "mismatched quotes double-single", input: `"bar'`, expected: `"bar'`},
		{name: "mismatched quotes single-double", input: `'bar"`, expected: `'bar"`},
		{name: "only opening double quote", input: `"bar`, expected: `"bar`},
		{name: "only closing double quote", input: `bar"`, expected: `bar"`},
		{name: "only opening single quote", input: "'bar", expected: "'bar"},
		{name: "only closing single quote", input: "bar'", expected: "bar'"},
		{name: "empty double quotes", input: `""`, expected: ""},
		{name: "empty single quotes", input: "''", expected: ""},
		{name: "nested double in single", input: `'"bar"'`, expected: `"bar"`},
		{name: "nested single in double", input: `"'bar'"`, expected: "'bar'"},
		{name: "single char", input: "a", expected: "a"},
		{name: "single double quote", input: `"`, expected: `"`},
		{name: "single single quote", input: "'", expected: "'"},
		{name: "spaces inside double quotes", input: `"hello world"`, expected: "hello world"},
		{name: "spaces inside single quotes", input: "'hello world'", expected: "hello world"},
		{name: "value with internal quotes", input: `"say \"hello\""`, expected: `say \"hello\"`},
		{name: "triple double quotes", input: `"""`, expected: `"`},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := trimQuotes(tc.input)
			assert.Check(t, is.Equal(result, tc.expected))
		})
	}
}

// Test ParseFromReader strips surrounding quotes from values
func TestParseFromReaderQuotedValues(t *testing.T) {
	content := `# Quoted values should have surrounding quotes stripped
DOUBLE_QUOTED="hello world"
SINGLE_QUOTED='hello world'
NO_QUOTES=hello
EMPTY_DOUBLE=""
EMPTY_SINGLE=''
MISMATCHED="hello'
NESTED_DOUBLE='"hello"'
NESTED_SINGLE="'hello'"
UNQUOTED_SPACES=hello world
INTERNAL_QUOTES=he"ll"o
ONLY_OPENING="hello
VALUE_WITH_EQUALS="foo=bar"
`

	lines, err := ParseFromReader(strings.NewReader(content), nil)
	assert.NilError(t, err)

	expectedLines := []string{
		"DOUBLE_QUOTED=hello world",
		"SINGLE_QUOTED=hello world",
		"NO_QUOTES=hello",
		"EMPTY_DOUBLE=",
		"EMPTY_SINGLE=",
		`MISMATCHED="hello'`,
		`NESTED_DOUBLE="hello"`,
		"NESTED_SINGLE='hello'",
		"UNQUOTED_SPACES=hello world",
		`INTERNAL_QUOTES=he"ll"o`,
		`ONLY_OPENING="hello`,
		"VALUE_WITH_EQUALS=foo=bar",
	}

	assert.Check(t, is.DeepEqual(lines, expectedLines))
}