main_test.go

//nolint:funlen //test
package main

import (
	"bufio"
	"bytes"
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"maps"
	"reflect"
	"regexp"
	"strings"
	"testing"
)

func testSilentLogger(t *testing.T) *log.Logger {
	t.Helper()

	return log.New(io.Discard, "", 0)
}

func TestURLRegex(t *testing.T) {
	tests := []struct {
		input string
		match bool
	}{
		{"http://example.com", true},
		{"https://example.com/path", true},
		{"www.example.com", true},
		{"ftp://host:21/path", true},
		{"git://repo.com/project.git", true},
		{"gemini://gemini.circumlunar.space", true},
		{"gopher://gopher.floodgap.com", true},
		{"not-a-url", false},
		{"http//missing-colon.com", false},
		{"htp://typo.com", false},
		{"example.com", false},
		{"example.com:8080", false},
		{"https://example.com:8080", true},
		{"https://example.com/path/to/file#section", true},
		{"https://example.com/path/to/file?query=param", true},
		{"HTTP://LOWERCASE.ORG", true},
		{"https://MixedCase.com", true},
	}

	urlExtractor, ok := builtInExtractors["url"]
	if !ok {
		t.Fatal("url extractor not found")
	}

	for _, tt := range tests {
		matched := urlExtractor.Regex.MatchString(tt.input)
		if matched != tt.match {
			t.Errorf("input: %q, expected match: %v, got: %v", tt.input, tt.match, matched)
		}
	}
}

func TestParseUserExtractors(t *testing.T) {
	type expectedMap map[ExtractorType]string

	tests := []struct {
		name    string
		specs   []string
		want    expectedMap
		wantErr error
	}{
		{
			name:    "valid_simple",
			specs:   []string{"token=[a-z]+"},
			want:    expectedMap{"token": "[a-z]+"},
			wantErr: nil,
		},
		{
			name:    "valid_whitespace_trim",
			specs:   []string{"  my_id  = ^[0-9]+$"},
			want:    expectedMap{"my_id": "^[0-9]+$"},
			wantErr: nil,
		},
		{
			name:    "invalid_format_missing_separator",
			specs:   []string{"token[a-z]+"},
			want:    nil,
			wantErr: ErrInvalidSpec,
		},
		{
			name:    "invalid_name_chars",
			specs:   []string{"bad!name:pattern"},
			want:    nil,
			wantErr: ErrInvalidSpec,
		},
		{
			name:    "invalid_regex_compilation",
			specs:   []string{fmt.Sprintf("broken%s(", extractorSep)},
			want:    nil,
			wantErr: ErrInvalidRegex,
		},
		{
			name:    "invalid_name",
			specs:   []string{"SomeName='+w'"},
			want:    nil,
			wantErr: ErrInvalidExtractor,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := parseUserExtractors(tt.specs)

			if tt.wantErr != nil {
				if err == nil {
					t.Fatalf("parseUserExtractors() expected error, got nil")
				}

				// if specific error var is provided, check is, otherwise just check presence
				if !errors.Is(err, tt.wantErr) {
					t.Errorf("parseUserExtractors() error = %v, wantErr %v", err, tt.wantErr)
				}

				return
			}

			if err != nil {
				t.Fatalf("parseUserExtractors() unexpected error: %v", err)
			}

			// check result count
			if len(got) != len(tt.want) {
				t.Fatalf("parseUserExtractors() returned %d items, want %d", len(got), len(tt.want))
			}

			// verify contents (name and regex pattern)
			for wantType, wantPattern := range tt.want {
				extractor, ok := got[wantType]
				if !ok {
					t.Errorf("parseUserExtractors() missing expected type: %s", wantType)
					continue
				}

				if extractor.Name != string(wantType) {
					t.Errorf("Extractor.Name = %q, want %q", extractor.Name, wantType)
				}

				// compare the compiled regex string representation
				if extractor.Regex.String() != wantPattern {
					t.Errorf("Extractor.Regex = %q, want %q", extractor.Regex.String(), wantPattern)
				}
			}
		})
	}
}

func TestScanItems(t *testing.T) {
	wordFinder := func(s string) []string {
		if s == "" {
			return nil
		}

		return strings.Fields(s)
	}

	type testCase struct {
		name   string
		args   *Args
		data   []string
		finder func(string) []string
		want   []string
	}

	tests := []testCase{
		{
			name: "normal_multiple_lines",
			args: &Args{maxResults: 0},
			data: []string{"a", "b", "c"},
			finder: func(s string) []string {
				return []string{s + "_x"}
			},
			want: []string{"a_x", "b_x", "c_x"},
		},
		{
			name: "limit_smaller_than_results",
			args: &Args{maxResults: 2},
			data: []string{"a", "b", "c"},
			finder: func(s string) []string {
				return []string{s}
			},
			want: []string{"a", "b"},
		},
		{
			name: "empty_input_data",
			args: &Args{maxResults: 0},
			data: []string{},
			finder: func(s string) []string {
				return []string{s}
			},
			want: []string{},
		},
		{
			name: "finder_returns_no_matches",
			args: &Args{maxResults: 0},
			data: []string{"a", "b"},
			finder: func(string) []string {
				return nil
			},
			want: []string{},
		},
		{
			name: "finder_returns_multiple_per_line_boundary",
			args: &Args{maxResults: 3},
			data: []string{"a", "b"},
			finder: func(s string) []string {
				return []string{s + "1", s + "2"}
			},
			want: []string{"a1", "a2", "b1"},
		},
		{
			name:   "normal_input",
			args:   &Args{maxResults: 1},
			data:   []string{"one two", "three"},
			finder: wordFinder,
			want:   []string{"one"},
		},
		{
			name:   "limit_boundary_exact",
			args:   &Args{maxResults: 2},
			data:   []string{"one two", "three"},
			finder: wordFinder,
			want:   []string{"one", "two"},
		},
		{
			name:   "empty_data_slice",
			args:   &Args{maxResults: 10},
			data:   []string{},
			finder: wordFinder,
			want:   []string{},
		},
		{
			name:   "zero_lines_empty_data",
			args:   &Args{maxResults: 0},
			data:   nil,
			finder: wordFinder,
			want:   nil,
		},
		{
			name:   "deduplicate_items_within_extractor",
			args:   &Args{maxResults: 0},
			data:   []string{"a", "b", "c", "a", "b", "c"},
			finder: wordFinder,
			want:   []string{"a", "b", "c"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := scanItems(tt.args, tt.data, tt.finder)

			if len(got) != len(tt.want) {
				t.Fatalf("scanItems() returned %d items, want %d: %v",
					len(got), len(tt.want), got)
			}

			for i := range got {
				if got[i] != tt.want[i] {
					t.Fatalf("scanItems()[%d] = %q; want %q",
						i, got[i], tt.want[i])
				}
			}
		})
	}
}

func TestParseTypes(t *testing.T) {
	mockReg := ExtractorRegistry{
		"url":   {},
		"email": {},
		"hash":  {},
		"ipv4":  {},
	}

	tests := []struct {
		name    string
		input   string
		reg     ExtractorRegistry
		want    []ExtractorType
		wantErr error
	}{
		{
			name:  "single_valid_type",
			input: "url",
			reg:   mockReg,
			want:  []ExtractorType{"url"},
		},
		{
			name:  "multiple_valid_types_preserve_order",
			input: "email,url,hash",
			reg:   mockReg,
			want:  []ExtractorType{"email", "url", "hash"},
		},
		{
			name:  "duplicates_are_deduplicated_preserve_first",
			input: "url,email,url,hash,email",
			reg:   mockReg,
			want:  []ExtractorType{"url", "email", "hash"},
		},
		{
			name:  "whitespace_is_trimmed",
			input: "  url ,  email ,hash ",
			reg:   mockReg,
			want:  []ExtractorType{"url", "email", "hash"},
		},
		// {
		// 	name:    "unknown_type_returns_error",
		// 	input:   "url,unknown",
		// 	reg:     mockReg,
		// 	want:    nil,
		// 	wantErr: ErrUnknownType,
		// },
		{
			name:  "empty_string_returns_empty_slice",
			input: "",
			reg:   mockReg,
			want:  []ExtractorType{},
		},
		{
			name:  "only_commas_and_empty_parts",
			input: ",,,",
			reg:   mockReg,
			want:  []ExtractorType{},
		},
		// {
		// 	name:    "nil_registry_causes_unknown_type_error",
		// 	input:   "url",
		// 	reg:     nil,
		// 	want:    nil,
		// 	wantErr: ErrUnknownType,
		// },
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := parseTypes(tt.input, tt.reg)

			if tt.wantErr != nil {
				if err == nil {
					t.Fatalf("parseTypes(%q) expected error %v, got nil", tt.input, tt.wantErr)
				}
				if !errors.Is(err, tt.wantErr) {
					t.Fatalf("parseTypes(%q) expected error %v, got %v", tt.input, tt.wantErr, err)
				}

				return
			}

			if err != nil {
				t.Fatalf("parseTypes(%q) unexpected error: %v", tt.input, err)
			}

			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("parseTypes(%q) = %#v; want %#v", tt.input, got, tt.want)
			}
		})
	}
}

func TestOutputData(t *testing.T) {
	tests := []struct {
		name       string
		args       *Args
		buffer     map[string][]string
		extractors []Extractor
		want       string
	}{
		{
			name: "single_extractor_single_item",
			args: &Args{writer: &bytes.Buffer{}},
			buffer: map[string][]string{
				"url": {"url:https://example.com"},
			},
			extractors: []Extractor{
				{Name: "url"},
			},
			want: "url:https://example.com\n",
		},
		{
			name: "multiple_extractors_preserve_order",
			args: &Args{writer: &bytes.Buffer{}},
			buffer: map[string][]string{
				"email": {"mailto:a@example.com"},
				"url":   {"url:https://example.com"},
			},
			extractors: []Extractor{
				{Name: "url"},
				{Name: "email"},
			},
			want: "url:https://example.com\nmailto:a@example.com\n",
		},
		{
			name: "skip_empty_items",
			args: &Args{writer: &bytes.Buffer{}},
			buffer: map[string][]string{
				"url": {"", "url:a", ""},
			},
			extractors: []Extractor{
				{Name: "url"},
			},
			want: "url:a\n",
		},
		{
			name: "index_enabled_across_extractors",
			args: &Args{index: true, writer: &bytes.Buffer{}},
			buffer: map[string][]string{
				"url":   {"url:a"},
				"email": {"mailto:b"},
			},
			extractors: []Extractor{
				{Name: "url"},
				{Name: "email"},
			},
			want: "[1] url:a\n[2] mailto:b\n",
		},
		{
			name:   "empty_buffer",
			args:   &Args{writer: &bytes.Buffer{}},
			buffer: map[string][]string{},
			extractors: []Extractor{
				{Name: "url"},
			},
			want: "",
		},
		{
			name:   "nil_buffer",
			args:   &Args{writer: &bytes.Buffer{}},
			buffer: nil,
			extractors: []Extractor{
				{Name: "url"},
			},
			want: "",
		},
		{
			name: "no_extractors",
			args: &Args{writer: &bytes.Buffer{}},
			buffer: map[string][]string{
				"url": {"url:a"},
			},
			extractors: nil,
			want:       "",
		},
		{
			name: "multiple_matches_with_prefix",
			args: &Args{writer: &bytes.Buffer{}, prefix: true},
			buffer: map[string][]string{
				"url": {"https://www.palandri.com", "https://www.palancoins.com"},
			},
			extractors: []Extractor{
				{Name: "url", Prefix: "u:"},
			},
			want: "u:https://www.palandri.com\nu:https://www.palancoins.com\n",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			buf, _ := tt.args.writer.(*bytes.Buffer)
			buf.Reset()

			outputData(tt.args, tt.buffer, tt.extractors)

			if got := buf.String(); got != tt.want {
				t.Fatalf("outputData() = %q; want %q", got, tt.want)
			}
		})
	}
}

func TestRunExtractor(t *testing.T) {
	tests := []struct {
		name string
		args *Args
		data []string
		ext  Extractor
		want Results
	}{
		{
			name: "regex_single_match_no_prefix",
			args: &Args{prefix: false},
			data: []string{"hello world"},
			ext: NewRegexExtractor(
				"word",
				regexp.MustCompile(`world`),
				"h:",
				"regex_single_match_no_prefix",
			),
			want: Results{
				Type: "word",
				Data: []string{"world"},
			},
		},
		{
			name: "custom_extract_overrides_regex",
			args: &Args{},
			data: []string{"ignore me"},
			ext: Extractor{
				Name:  "custom",
				Regex: regexp.MustCompile(`ignore`),
				Extract: func(args *Args, line string) []string {
					return []string{"custom-value"}
				},
			},
			want: Results{
				Type: "custom",
				Data: []string{"custom-value"},
			},
		},
		{
			name: "custom_extract_returns_empty",
			args: &Args{},
			data: []string{"something"},
			ext: Extractor{
				Name: "custom",
				Extract: func(args *Args, line string) []string {
					return nil
				},
			},
			want: Results{
				Type: "custom",
				Data: []string{},
			},
		},
		{
			name: "empty_data_slice",
			args: &Args{},
			data: []string{},
			ext: NewRegexExtractor(
				"word",
				regexp.MustCompile(`\w+`),
				"w:",
				"empty_data_slice",
			),
			want: Results{
				Type: "word",
				Data: []string{},
			},
		},
		{
			name: "nil_data_slice",
			args: &Args{},
			data: nil,
			ext: Extractor{
				Name:  "word",
				Regex: regexp.MustCompile(`\w+`),
			},
			want: Results{
				Type: "word",
				Data: []string{},
			},
		},
		{
			name: "regex_no_matches",
			args: &Args{},
			data: []string{"abc"},
			ext: NewRegexExtractor(
				"digits",
				regexp.MustCompile(`\d+`),
				"d:",
				"regex_no_matches",
			),
			want: Results{
				Type: "digits",
				Data: []string{},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := runExtractor(tt.args, tt.data, tt.ext, testSilentLogger(t))

			if got.Type != tt.want.Type {
				t.Fatalf("runExtractor() type = %q; want %q", got.Type, tt.want.Type)
			}

			if !reflect.DeepEqual(got.Data, tt.want.Data) {
				t.Fatalf("runExtractor() data = %#v; want %#v", got.Data, tt.want.Data)
			}
		})
	}
}

func TestProcessInputData(t *testing.T) {
	tests := []struct {
		name      string
		scanner   *bufio.Scanner
		want      []string
		wantErr   bool
		wantPanic bool
	}{
		{
			name:    "multiple_lines",
			scanner: bufio.NewScanner(strings.NewReader("one\ntwo\nthree")),
			want:    []string{"one", "two", "three"},
			wantErr: false,
		},
		{
			name:    "single_line",
			scanner: bufio.NewScanner(strings.NewReader("onlyline")),
			want:    []string{"onlyline"},
			wantErr: false,
		},
		{
			name:    "empty_input",
			scanner: bufio.NewScanner(strings.NewReader("")),
			want:    nil,
			wantErr: false,
		},
		{
			name:    "empty_lines",
			scanner: bufio.NewScanner(strings.NewReader("\n\n")),
			want:    []string{"", ""},
			wantErr: false,
		},
		{
			name:      "nil_scanner_panics",
			scanner:   nil,
			want:      nil,
			wantErr:   false,
			wantPanic: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.wantPanic {
				defer func() {
					if r := recover(); r == nil {
						t.Fatalf("expected panic, got none")
					}
				}()
			}

			got, err := processInputData(tt.scanner)
			if tt.wantPanic {
				return
			}

			if tt.wantErr {
				if err == nil {
					t.Fatalf("expected error, got nil")
				}

				return
			}

			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			if !reflect.DeepEqual(got, tt.want) {
				t.Fatalf("processInputData() = %v; want %v", got, tt.want)
			}
		})
	}
}

func testReg(items ExtractorRegistry) ExtractorRegistry {
	r := make(ExtractorRegistry, len(items))
	maps.Copy(r, items)
	return r
}

func TestBuildExtractorRegistry(t *testing.T) {
	origBuiltins := builtInExtractors
	t.Cleanup(func() {
		builtInExtractors = origBuiltins
	})

	tests := []struct {
		name     string
		args     *Args
		builtins ExtractorRegistry
		wantKeys []string
		wantErr  bool
	}{
		{
			name: "normal_combined_builtin_and_user_extractors",
			args: &Args{
				extractors: []string{
					"lines='w+'",
				},
			},
			builtins: testReg(ExtractorRegistry{
				"url": {Name: "url"},
			}),
			wantKeys: []string{"url", "lines"},
			wantErr:  false,
		},
		{
			name: "only_builtin_extractors",
			args: &Args{
				extractors: nil,
			},
			builtins: testReg(ExtractorRegistry{
				"url":   {Name: "url"},
				"email": {Name: "email"},
			}),
			wantKeys: []string{"url", "email"},
			wantErr:  false,
		},
		{
			name: "only_user_extractors",
			args: &Args{
				extractors: []string{
					"lines='w+'",
				},
			},
			builtins: testReg(ExtractorRegistry{}),
			wantKeys: []string{"lines"},
			wantErr:  false,
		},
		{
			name: "user_extractor_overrides_builtin",
			args: &Args{
				extractors: []string{
					"lines='w+'",
				},
			},
			builtins: testReg(ExtractorRegistry{
				"lines": {Name: "lines", Prefix: "builtin:"},
			}),
			wantKeys: []string{"lines"},
			wantErr:  false,
		},
		{
			name: "invalid_user_extractor_returns_error",
			args: &Args{
				extractors: []string{
					"!!!invalid!!!",
				},
			},
			builtins: testReg(ExtractorRegistry{
				"url": {Name: "url"},
			}),
			wantKeys: nil,
			wantErr:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			builtInExtractors = tt.builtins
			got, err := buildExtractorRegistry(tt.args)

			if tt.wantErr {
				if err == nil {
					t.Fatalf("expected error, got nil")
				}

				return
			}

			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			if len(got) != len(tt.wantKeys) {
				t.Fatalf("registry size = %d; want %d", len(got), len(tt.wantKeys))
			}

			for _, k := range tt.wantKeys {
				if _, ok := got[ExtractorType(k)]; !ok {
					t.Fatalf("missing extractor %q in registry", k)
				}
			}
		})
	}
}

func TestResolveTypes(t *testing.T) {
	reg := ExtractorRegistry{
		"email": {},
		"path":  {},
		"sha":   {},
	}

	tests := []struct {
		name    string
		args    *Args
		reg     ExtractorRegistry
		want    []ExtractorType
		wantErr bool
	}{
		{
			name: "explicit_types_preserve_order",
			args: &Args{types: "path,email"},
			reg:  reg,
			// order must be preserved by parseTypes
			want: []ExtractorType{"path", "email"},
		},
		{
			name: "default_types_sorted_alphabetically",
			args: &Args{types: ""},
			reg:  reg,
			// alphabetical order: email, path, sha
			want: []ExtractorType{"email", "path", "sha"},
		},
		{
			name: "empty_registry_with_no_types",
			args: &Args{types: ""},
			reg:  ExtractorRegistry{},
			// boundary: zero-length registry
			want: []ExtractorType{},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := resolveTypes(tt.args, tt.reg)

			if tt.wantErr {
				if err == nil {
					t.Fatalf("resolveTypes() expected error, got nil")
				}

				return
			}

			if err != nil {
				t.Fatalf("resolveTypes() unexpected error: %v", err)
			}

			if len(got) != len(tt.want) {
				t.Fatalf("resolveTypes() len = %d; want %d", len(got), len(tt.want))
			}

			for i := range got {
				if got[i] != tt.want[i] {
					t.Fatalf(
						"resolveTypes()[%d] = %q; want %q",
						i, got[i], tt.want[i],
					)
				}
			}
		})
	}
}

func TestSelectExtractors(t *testing.T) {
	ext := func(name string) Extractor {
		return Extractor{Name: name}
	}

	tests := []struct {
		name    string
		reg     ExtractorRegistry
		order   []ExtractorType
		want    []Extractor
		wantErr error
	}{
		{
			name: "normal_ordered_subset",
			reg: ExtractorRegistry{
				"email": ext("email"),
				"ipv4":  ext("ipv4"),
				"url":   ext("url"),
			},
			// Request a subset in a specific order (different from map insertion)
			order:   []ExtractorType{"url", "email"},
			want:    []Extractor{ext("url"), ext("email")},
			wantErr: nil,
		},
		{
			name: "skip_unknown_types",
			reg: ExtractorRegistry{
				"valid": ext("valid"),
			},
			// "missing" should be silently skipped
			order:   []ExtractorType{"valid", "missing"},
			want:    []Extractor{ext("valid")},
			wantErr: nil,
		},
		{
			name: "allow_duplicates_in_order",
			reg: ExtractorRegistry{
				"token": ext("token"),
			},
			// If the user requests the same type twice, it should appear twice
			order:   []ExtractorType{"token", "token"},
			want:    []Extractor{ext("token"), ext("token")},
			wantErr: nil,
		},
		{
			name:    "empty_order_returns_empty",
			reg:     ExtractorRegistry{"any": ext("any")},
			order:   []ExtractorType{},
			want:    []Extractor{},
			wantErr: nil,
		},
		{
			name:    "nil_inputs_safe",
			reg:     nil,
			order:   nil,
			want:    []Extractor{},
			wantErr: nil,
		},
		{
			name:    "invalid_extractor",
			reg:     ExtractorRegistry{"any": ext("")},
			order:   []ExtractorType{"any"},
			want:    nil,
			wantErr: ErrInvalidExtractor,
		},
		{
			name:    "invalid_extractor_name",
			reg:     ExtractorRegistry{"any": ext("InvalidName")},
			order:   []ExtractorType{"any"},
			want:    nil,
			wantErr: ErrInvalidExtractor,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := selectExtractors(tt.reg, tt.order)

			if tt.wantErr != nil {
				if err == nil {
					t.Fatalf("selectExtractors() expected error, got nil")
				}
				if !errors.Is(err, tt.wantErr) {
					t.Errorf("selectExtractors() error = %v, want %v", err, tt.wantErr)
				}

				return
			}
			if err != nil {
				t.Fatalf("selectExtractors() unexpected error: %v", err)
			}

			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("selectExtractors() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestExecute(t *testing.T) {
	tests := []struct {
		name    string
		args    *Args
		data    []string
		wantErr bool
	}{
		{
			name: "success_normal_input",
			args: &Args{
				writer: &bytes.Buffer{},
				types:  "url",
			},
			data:    []string{"Check this https://google.com", "No url here"},
			wantErr: false,
		},
		{
			name: "success_empty_data",
			args: &Args{
				writer: &bytes.Buffer{},
				types:  "email",
			},
			data:    []string{}, // Empty input should not crash
			wantErr: false,
		},
		{
			name: "error_broken_custom_regex",
			args: &Args{
				writer: &bytes.Buffer{},
				// Invalid regex syntax "(" should fail during registry build
				extractors: []string{"broken_regex=("},
				types:      "broken_regex",
			},
			data:    []string{"data"},
			wantErr: true,
		},
		{
			name: "success_multiple_extractors_fan_out",
			args: &Args{
				writer: &bytes.Buffer{},
				types:  "url,email", // Tests the fan-out/fan-in loop
			},
			data:    []string{"contact: test@example.com website: http://example.com"},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			app := NewApp("gurl", "0.1.0")
			app.Data = tt.data
			app.Args = tt.args
			err := Execute(app)

			// Check error expectations
			if tt.wantErr {
				if err == nil {
					t.Fatal("Runner.Run() expected error, got nil")
				}

				return
			}

			if err != nil {
				t.Fatalf("Runner.Run() unexpected error: %v", err)
			}
		})
	}
}

func TestApp_parseFlags(t *testing.T) {
	tests := []struct {
		name    string
		args    []string
		want    Args
		wantErr bool
	}{
		{
			name: "defaults_no_args",
			args: []string{},
			want: Args{
				types:      "url",
				prefix:     false,
				maxResults: 0,
				verbose:    false,
				index:      false,
				version:    false,
				list:       false,
			},
			wantErr: false,
		},
		{
			name: "short_flags_typical",
			args: []string{"-t", "url,email", "-p", "-n", "10", "-v", "-i"},
			want: Args{
				types:      "url,email",
				prefix:     true,
				maxResults: 10,
				verbose:    true,
				index:      true,
			},
			wantErr: false,
		},
		{
			name: "long_flags_typical",
			args: []string{"--type", "hash", "--prefix", "--lines", "3", "--verbose", "--list"},
			want: Args{
				types:      "hash",
				prefix:     true,
				maxResults: 3,
				verbose:    true,
				list:       true,
			},
			wantErr: false,
		},
		{
			name: "boundary_large_max_results",
			args: []string{"-n", "1000000"},
			want: Args{
				types:      "url",
				maxResults: 1_000_000,
			},
			wantErr: false,
		},
		{
			name:    "unknown_flag_error",
			args:    []string{"--does-not-exist"},
			want:    Args{},
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			app := &App{
				Args: &Args{},
				Flag: flag.NewFlagSet("test", flag.ContinueOnError),
			}

			// suppress flag output during tests
			app.Flag.SetOutput(io.Discard)

			err := app.parseFlags(tt.args)

			if tt.wantErr {
				if err == nil {
					t.Fatalf("parseFlags(%v) expected error, got nil", tt.args)
				}

				return
			}

			if err != nil {
				t.Fatalf("parseFlags(%v) unexpected error: %v", tt.args, err)
			}

			if app.Args.types != tt.want.types {
				t.Fatalf("types = %q; want %q", app.Args.types, tt.want.types)
			}
			if app.Args.prefix != tt.want.prefix {
				t.Fatalf("prefix = %v; want %v", app.Args.prefix, tt.want.prefix)
			}
			if app.Args.maxResults != tt.want.maxResults {
				t.Fatalf("maxResults = %d; want %d", app.Args.maxResults, tt.want.maxResults)
			}
			if app.Args.verbose != tt.want.verbose {
				t.Fatalf("verbose = %v; want %v", app.Args.verbose, tt.want.verbose)
			}
			if app.Args.index != tt.want.index {
				t.Fatalf("index = %v; want %v", app.Args.index, tt.want.index)
			}
			if app.Args.version != tt.want.version {
				t.Fatalf("version = %v; want %v", app.Args.version, tt.want.version)
			}
			if app.Args.list != tt.want.list {
				t.Fatalf("list = %v; want %v", app.Args.list, tt.want.list)
			}
		})
	}
}

func TestConfigLoad(t *testing.T) {
	t.Skip("not implemented yet...")
}