chore: add some test (#18)

Author: y3owk1n

internal/accessibility/query_test.go

@@ -0,0 +1,85 @@
+package accessibility
+
+import (
+	"image"
+	"testing"
+)
+
+func TestRectFromInfo(t *testing.T) {
+	tests := []struct {
+		name string
+		info *ElementInfo
+		want image.Rectangle
+	}{
+		{
+			name: "Basic rectangle",
+			info: &ElementInfo{
+				Position: image.Point{X: 10, Y: 20},
+				Size:     image.Point{X: 100, Y: 50},
+			},
+			want: image.Rect(10, 20, 110, 70),
+		},
+		{
+			name: "Zero size",
+			info: &ElementInfo{
+				Position: image.Point{X: 5, Y: 5},
+				Size:     image.Point{X: 0, Y: 0},
+			},
+			want: image.Rect(5, 5, 5, 5),
+		},
+		{
+			name: "Negative position",
+			info: &ElementInfo{
+				Position: image.Point{X: -10, Y: -20},
+				Size:     image.Point{X: 30, Y: 40},
+			},
+			want: image.Rect(-10, -20, 20, 20),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := rectFromInfo(tt.info)
+			if got != tt.want {
+				t.Errorf("rectFromInfo() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestExpandRectangle(t *testing.T) {
+	tests := []struct {
+		name    string
+		rect    image.Rectangle
+		padding int
+		want    image.Rectangle
+	}{
+		{
+			name:    "Expand by 5",
+			rect:    image.Rect(10, 10, 20, 20),
+			padding: 5,
+			want:    image.Rect(5, 5, 25, 25),
+		},
+		{
+			name:    "Expand by 0",
+			rect:    image.Rect(10, 10, 20, 20),
+			padding: 0,
+			want:    image.Rect(10, 10, 20, 20),
+		},
+		{
+			name:    "Expand by negative",
+			rect:    image.Rect(10, 10, 20, 20),
+			padding: -2,
+			want:    image.Rect(12, 12, 18, 18),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := expandRectangle(tt.rect, tt.padding)
+			if got != tt.want {
+				t.Errorf("expandRectangle() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/config/config_test.go

@@ -116,6 +116,60 @@ func TestLoadNonExistentFile(t *testing.T) {
 	}
 }
 
+func TestConfigWithAppSpecificSettings(t *testing.T) {
+	// Create a config with app-specific settings
+	cfg := DefaultConfig()
+
+	// Add app-specific configurations
+	cfg.Accessibility.AppConfigs = []AppConfig{
+		{
+			BundleID:             "com.example.app1",
+			AdditionalClickable:  []string{"CustomButton1", "CustomLink1"},
+			AdditionalScrollable: []string{"CustomScroll1"},
+		},
+		{
+			BundleID:             "com.example.app2",
+			AdditionalClickable:  []string{"CustomButton2"},
+			AdditionalScrollable: []string{"CustomScroll2", "CustomPanel2"},
+		},
+	}
+
+	// Test getting clickable roles for specific app
+	clickableRoles := cfg.GetClickableRolesForApp("com.example.app1")
+
+	// Should include both default and app-specific roles
+	defaultCount := len(cfg.Accessibility.ClickableRoles)
+	expectedCount := defaultCount + 2 // Default + 2 custom roles
+
+	if len(clickableRoles) != expectedCount {
+		t.Errorf("Expected %d clickable roles, got %d", expectedCount, len(clickableRoles))
+	}
+
+	// Check if app-specific roles are included
+	found := false
+	for _, role := range clickableRoles {
+		if role == "CustomButton1" {
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		t.Errorf("App-specific role 'CustomButton1' not found in clickable roles")
+	}
+
+	// Test getting scrollable roles for specific app
+	scrollableRoles := cfg.GetScrollableRolesForApp("com.example.app2")
+
+	// Should include both default and app-specific roles
+	defaultScrollCount := len(cfg.Accessibility.ScrollableRoles)
+	expectedScrollCount := defaultScrollCount + 2 // Default + 2 custom roles
+
+	if len(scrollableRoles) != expectedScrollCount {
+		t.Errorf("Expected %d scrollable roles, got %d", expectedScrollCount, len(scrollableRoles))
+	}
+}
+
 func TestGetConfigPath(t *testing.T) {
 	path := GetConfigPath()
 	if path == "" {

internal/hints/generator_test.go

@@ -192,6 +192,114 @@ func TestHintIsVisible(t *testing.T) {
 	}
 }
 
+func TestGenerate(t *testing.T) {
+	// Create test elements
+	elements := []*accessibility.TreeNode{
+		{
+			Info: &accessibility.ElementInfo{
+				Position: image.Point{X: 10, Y: 10},
+				Size:     image.Point{X: 20, Y: 20},
+				Role:     "button",
+			},
+		},
+		{
+			Info: &accessibility.ElementInfo{
+				Position: image.Point{X: 50, Y: 10},
+				Size:     image.Point{X: 20, Y: 20},
+				Role:     "link",
+			},
+		},
+		{
+			Info: &accessibility.ElementInfo{
+				Position: image.Point{X: 10, Y: 50},
+				Size:     image.Point{X: 20, Y: 20},
+				Role:     "checkbox",
+			},
+		},
+	}
+
+	tests := []struct {
+		name       string
+		characters string
+		style      string
+		maxHints   int
+		elements   []*accessibility.TreeNode
+		wantCount  int
+		wantLabels []string
+	}{
+		{
+			name:       "alphabet style",
+			characters: "asdf",
+			style:      "alphabet",
+			maxHints:   10,
+			elements:   elements,
+			wantCount:  3,
+			wantLabels: []string{"A", "S", "D"},
+		},
+		{
+			name:       "numeric style",
+			characters: "asdf",
+			style:      "numeric",
+			maxHints:   10,
+			elements:   elements,
+			wantCount:  3,
+			wantLabels: []string{"1", "2", "3"},
+		},
+		{
+			name:       "limited hints",
+			characters: "asdf",
+			style:      "alphabet",
+			maxHints:   2,
+			elements:   elements,
+			wantCount:  2,
+			wantLabels: []string{"A", "S"},
+		},
+		{
+			name:       "empty elements",
+			characters: "asdf",
+			style:      "alphabet",
+			maxHints:   10,
+			elements:   []*accessibility.TreeNode{},
+			wantCount:  0,
+			wantLabels: []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			generator := NewGenerator(tt.characters, tt.style, tt.maxHints)
+			hints, err := generator.Generate(tt.elements)
+
+			if err != nil {
+				t.Fatalf("Generate() error = %v", err)
+			}
+
+			if len(hints) != tt.wantCount {
+				t.Errorf("Generate() returned %d hints, want %d", len(hints), tt.wantCount)
+			}
+
+			// Check labels
+			for i, hint := range hints {
+				if i < len(tt.wantLabels) && hint.Label != tt.wantLabels[i] {
+					t.Errorf("Generate() hint[%d].Label = %s, want %s", i, hint.Label, tt.wantLabels[i])
+				}
+			}
+
+			// Check positions are centered
+			for i, hint := range hints {
+				element := tt.elements[i]
+				expectedX := element.Info.Position.X + (element.Info.Size.X / 2)
+				expectedY := element.Info.Position.Y + (element.Info.Size.Y / 2)
+
+				if hint.Position.X != expectedX || hint.Position.Y != expectedY {
+					t.Errorf("Generate() hint[%d].Position = (%d,%d), want (%d,%d)",
+						i, hint.Position.X, hint.Position.Y, expectedX, expectedY)
+				}
+			}
+		})
+	}
+}
+
 func TestHintCollection(t *testing.T) {
 	hints := []*Hint{
 		{Label: "a"},

internal/scroll/controller_test.go

@@ -32,3 +32,27 @@ func TestController_BasicOperations(t *testing.T) {
 	// This is a basic smoke test
 	_ = controller
 }
+
+func TestScrollDirections(t *testing.T) {
+	// Test that direction constants are defined correctly
+	directions := []Direction{DirectionUp, DirectionDown, DirectionLeft, DirectionRight}
+	expectedValues := []int{0, 1, 2, 3}
+
+	for i, dir := range directions {
+		if int(dir) != expectedValues[i] {
+			t.Errorf("Direction constant %d has unexpected value %d", i, dir)
+		}
+	}
+}
+
+func TestScrollAmounts(t *testing.T) {
+	// Test that amount constants are defined correctly
+	amounts := []ScrollAmount{AmountChar, AmountHalfPage, AmountFullPage}
+	expectedValues := []int{0, 1, 2}
+
+	for i, amount := range amounts {
+		if int(amount) != expectedValues[i] {
+			t.Errorf("ScrollAmount constant %d has unexpected value %d", i, amount)
+		}
+	}
+}