add tests

2025-08-21 18:09:00 +02:00
parent ddef3435f6
commit 03e5e6e66b
10 changed files with 3603 additions and 0 deletions
@@ -0,0 +1,354 @@
+package injection
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestNewInjector(t *testing.T) {
+	config := Config{
+		Mode:             "fallback",
+		RestoreClipboard: true,
+		WtypeTimeout:     5 * time.Second,
+		ClipboardTimeout: 3 * time.Second,
+	}
+
+	injector := NewInjector(config)
+	if injector == nil {
+		t.Errorf("NewInjector() returned nil")
+		return
+	}
+
+	// Test that the injector works with the expected config
+	ctx := context.Background()
+	err := injector.Inject(ctx, "test")
+	// We expect this to fail due to missing external tools, but it should be the right type of error
+	if err != nil {
+		t.Logf("Injector created successfully (failed as expected due to missing tools): %v", err)
+	}
+}
+
+func TestInjector_Inject(t *testing.T) {
+	tests := []struct {
+		name    string
+		config  Config
+		text    string
+		wantErr bool
+	}{
+		{
+			name: "inject with clipboard mode",
+			config: Config{
+				Mode:             "clipboard",
+				RestoreClipboard: false,
+				WtypeTimeout:     5 * time.Second,
+				ClipboardTimeout: 3 * time.Second,
+			},
+			text:    "test text",
+			wantErr: false,
+		},
+		{
+			name: "inject with type mode",
+			config: Config{
+				Mode:             "type",
+				RestoreClipboard: false,
+				WtypeTimeout:     5 * time.Second,
+				ClipboardTimeout: 3 * time.Second,
+			},
+			text:    "test text",
+			wantErr: false,
+		},
+		{
+			name: "inject with fallback mode",
+			config: Config{
+				Mode:             "fallback",
+				RestoreClipboard: false,
+				WtypeTimeout:     5 * time.Second,
+				ClipboardTimeout: 3 * time.Second,
+			},
+			text:    "test text",
+			wantErr: false,
+		},
+		{
+			name: "inject empty text",
+			config: Config{
+				Mode:             "clipboard",
+				RestoreClipboard: false,
+				WtypeTimeout:     5 * time.Second,
+				ClipboardTimeout: 3 * time.Second,
+			},
+			text:    "",
+			wantErr: true,
+		},
+		{
+			name: "inject with invalid mode",
+			config: Config{
+				Mode:             "invalid",
+				RestoreClipboard: false,
+				WtypeTimeout:     5 * time.Second,
+				ClipboardTimeout: 3 * time.Second,
+			},
+			text:    "test text",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			injector := NewInjector(tt.config)
+			ctx := context.Background()
+
+			err := injector.Inject(ctx, tt.text)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Inject() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestConfig(t *testing.T) {
+	config := Config{
+		Mode:             "fallback",
+		RestoreClipboard: true,
+		WtypeTimeout:     5 * time.Second,
+		ClipboardTimeout: 3 * time.Second,
+	}
+
+	if config.Mode != "fallback" {
+		t.Errorf("Mode mismatch: got %s, want %s", config.Mode, "fallback")
+	}
+
+	if !config.RestoreClipboard {
+		t.Errorf("RestoreClipboard should be true")
+	}
+
+	if config.WtypeTimeout != 5*time.Second {
+		t.Errorf("WtypeTimeout mismatch: got %v, want %v", config.WtypeTimeout, 5*time.Second)
+	}
+
+	if config.ClipboardTimeout != 3*time.Second {
+		t.Errorf("ClipboardTimeout mismatch: got %v, want %v", config.ClipboardTimeout, 3*time.Second)
+	}
+}
+
+// TestTypeText tests the typeText function
+func TestTypeText(t *testing.T) {
+	tests := []struct {
+		name    string
+		text    string
+		wantErr bool
+	}{
+		{
+			name:    "type normal text",
+			text:    "hello world",
+			wantErr: false,
+		},
+		{
+			name:    "type empty text",
+			text:    "",
+			wantErr: false,
+		},
+		{
+			name:    "type text with special characters",
+			text:    "hello\nworld\t!",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+			defer cancel()
+
+			err := typeText(ctx, tt.text, 1*time.Second)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("typeText() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+// TestCheckWtypeAvailable tests the wtype availability check
+func TestCheckWtypeAvailable(t *testing.T) {
+	err := checkWtypeAvailable()
+	if err != nil {
+		t.Logf("checkWtypeAvailable() failed (expected if wtype not installed): %v", err)
+		// Don't fail the test if wtype is not available
+		return
+	}
+
+	t.Logf("checkWtypeAvailable() succeeded - wtype is available")
+}
+
+// TestGetClipboard tests the clipboard get functionality
+func TestGetClipboard(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	// Test getting clipboard content
+	content, err := getClipboard(ctx, 1*time.Second)
+	if err != nil {
+		t.Logf("getClipboard() failed (expected if wl-paste not available): %v", err)
+		// Don't fail the test if clipboard tools are not available
+		return
+	}
+
+	t.Logf("getClipboard() succeeded, content length: %d", len(content))
+}
+
+// TestSetClipboard tests the clipboard set functionality
+func TestSetClipboard(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	testText := "test clipboard content"
+
+	err := setClipboard(ctx, testText, 1*time.Second)
+	if err != nil {
+		t.Logf("setClipboard() failed (expected if wl-copy not available): %v", err)
+		// Don't fail the test if clipboard tools are not available
+		return
+	}
+
+	t.Logf("setClipboard() succeeded")
+
+	// Try to read it back
+	content, err := getClipboard(ctx, 1*time.Second)
+	if err != nil {
+		t.Logf("Failed to read back clipboard content: %v", err)
+		return
+	}
+
+	if content != testText {
+		t.Logf("Clipboard content mismatch: got %q, want %q", content, testText)
+		// Don't fail - clipboard might have been modified by other processes
+	}
+}
+
+// TestCheckClipboardAvailable tests the clipboard tools availability check
+func TestCheckClipboardAvailable(t *testing.T) {
+	err := checkClipboardAvailable()
+	if err != nil {
+		t.Logf("checkClipboardAvailable() failed (expected if clipboard tools not installed): %v", err)
+		// Don't fail the test if clipboard tools are not available
+		return
+	}
+
+	t.Logf("checkClipboardAvailable() succeeded - clipboard tools are available")
+}
+
+// TestInjector_ClipboardMode tests clipboard-only injection
+func TestInjector_ClipboardMode(t *testing.T) {
+	config := Config{
+		Mode:             "clipboard",
+		RestoreClipboard: false,
+		WtypeTimeout:     5 * time.Second,
+		ClipboardTimeout: 3 * time.Second,
+	}
+
+	injector := NewInjector(config)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	err := injector.Inject(ctx, "test clipboard text")
+	if err != nil {
+		t.Logf("Clipboard injection failed (expected if clipboard tools not available): %v", err)
+		// Don't fail the test if clipboard tools are not available
+		return
+	}
+
+	t.Logf("Clipboard injection succeeded")
+}
+
+// TestInjector_TypeMode tests typing-only injection
+func TestInjector_TypeMode(t *testing.T) {
+	config := Config{
+		Mode:             "type",
+		RestoreClipboard: false,
+		WtypeTimeout:     5 * time.Second,
+		ClipboardTimeout: 3 * time.Second,
+	}
+
+	injector := NewInjector(config)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	err := injector.Inject(ctx, "test typing text")
+	if err != nil {
+		t.Logf("Typing injection failed (expected if wtype not available): %v", err)
+		// Don't fail the test if wtype is not available
+		return
+	}
+
+	t.Logf("Typing injection succeeded")
+}
+
+// TestInjector_FallbackMode tests fallback injection behavior
+func TestInjector_FallbackMode(t *testing.T) {
+	config := Config{
+		Mode:             "fallback",
+		RestoreClipboard: false,
+		WtypeTimeout:     5 * time.Second,
+		ClipboardTimeout: 3 * time.Second,
+	}
+
+	injector := NewInjector(config)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	err := injector.Inject(ctx, "test fallback text")
+	if err != nil {
+		t.Logf("Fallback injection failed (expected if both wtype and clipboard tools not available): %v", err)
+		// Don't fail the test if tools are not available
+		return
+	}
+
+	t.Logf("Fallback injection succeeded")
+}
+
+// TestInjector_EmptyText tests injection of empty text
+func TestInjector_EmptyText(t *testing.T) {
+	config := Config{
+		Mode:             "clipboard",
+		RestoreClipboard: false,
+		WtypeTimeout:     5 * time.Second,
+		ClipboardTimeout: 3 * time.Second,
+	}
+
+	injector := NewInjector(config)
+	ctx := context.Background()
+
+	err := injector.Inject(ctx, "")
+	if err == nil {
+		t.Errorf("Inject() should fail with empty text")
+		return
+	}
+
+	if err.Error() != "cannot inject empty text" {
+		t.Errorf("Inject() error message = %q, want %q", err.Error(), "cannot inject empty text")
+	}
+}
+
+// TestInjector_InvalidMode tests injection with invalid mode
+func TestInjector_InvalidMode(t *testing.T) {
+	config := Config{
+		Mode:             "invalid",
+		RestoreClipboard: false,
+		WtypeTimeout:     5 * time.Second,
+		ClipboardTimeout: 3 * time.Second,
+	}
+
+	injector := NewInjector(config)
+	ctx := context.Background()
+
+	err := injector.Inject(ctx, "test text")
+	if err == nil {
+		t.Errorf("Inject() should fail with invalid mode")
+		return
+	}
+
+	expectedError := "unsupported injection mode: invalid"
+	if err.Error() != expectedError {
+		t.Errorf("Inject() error message = %q, want %q", err.Error(), expectedError)
+	}
+}