feat: harden runtime import and frontend verification workflows

internal/errs/common.go

@@ -24,10 +24,10 @@ var (
 
 // Overlay 错误
 var (
-	ErrOverlayNotMatched    = errors.New("overlay did not match")
-	ErrNestedOutput         = errors.New("output directory must not be nested inside source directory")
-	ErrOutputExists         = errors.New("output directory already exists")
-	ErrSourceNotDir         = errors.New("source must be a directory")
-	ErrPatchFileNotFound    = errors.New("patch file not found")
-	ErrPatchApplyFailed     = errors.New("failed to apply patch")
+	ErrOverlayNotMatched = errors.New("overlay did not match")
+	ErrNestedOutput      = errors.New("output directory must not be nested inside source directory")
+	ErrOutputExists      = errors.New("output directory already exists")
+	ErrSourceNotDir      = errors.New("source must be a directory")
+	ErrPatchFileNotFound = errors.New("patch file not found")
+	ErrPatchApplyFailed  = errors.New("failed to apply patch")
 )

internal/errs/test_helpers_test.go

@@ -0,0 +1,113 @@
+package errs
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestContainsSubstring(t *testing.T) {
+	tests := []struct {
+		name   string
+		s      string
+		substr string
+		want   bool
+	}{
+		{"exact match", "hello", "hello", true},
+		{"substring at start", "hello world", "hello", true},
+		{"substring at end", "hello world", "world", true},
+		{"substring in middle", "hello world foo", "world", true},
+		{"no match", "hello", "world", false},
+		{"empty string", "", "", true},
+		{"empty substring", "hello", "", true},
+		{"substr longer than s", "hi", "hello world", false},
+		{"partial match only", "hello", "hello world", false},
+		{"case sensitive", "Hello", "hello", false},
+		{"unicode substring", "你好世界", "世界", true},
+		{"unicode no match", "你好世界", "hello", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := containsSubstring(tt.s, tt.substr)
+			if got != tt.want {
+				t.Errorf("containsSubstring(%q, %q) = %v, want %v", tt.s, tt.substr, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestContainsAt(t *testing.T) {
+	tests := []struct {
+		name   string
+		s      string
+		substr string
+		start  int
+		want   bool
+	}{
+		{"find at start", "hello world", "hello", 0, true},
+		{"find at offset", "hello world", "world", 6, true},
+		{"find with start inside", "hello world hello", "hello", 6, true},
+		{"not found after offset", "hello world", "hello", 6, false},
+		{"start beyond string", "hello", "lo", 10, false},
+		{"empty substr at start", "hello", "", 0, true},
+		{"empty substr at end", "hello", "", 5, true},
+		{"start at exact position", "hello world", "world", 6, true},
+		{"start_just_before", "hello world", "world", 5, true}, // "world" starts at index 6, so start=5 is within range
+		{"multiple occurrences", "ababab", "ab", 2, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := containsAt(tt.s, tt.substr, tt.start)
+			if got != tt.want {
+				t.Errorf("containsAt(%q, %q, %d) = %v, want %v", tt.s, tt.substr, tt.start, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestAssertErrorContains_Success(t *testing.T) {
+	// This should pass - error contains substring
+	// Just verify it doesn't panic/fail
+	err := &testError{msg: "connection refused: something went wrong"}
+	AssertErrorContains(t, err, "connection refused")
+}
+
+func TestAssertErrorContains_EmptySubstring(t *testing.T) {
+	// Empty substring should pass with any error
+	err := &testError{msg: "any error"}
+	AssertErrorContains(t, err, "")
+}
+
+// testError is a simple error implementation for testing
+type testError struct {
+	msg string
+}
+
+func (e *testError) Error() string {
+	return e.msg
+}
+
+// TestContainsSubstring_StandardLibrary verifies our implementation matches strings.Contains
+func TestContainsSubstring_StandardLibrary(t *testing.T) {
+	testCases := []struct {
+		s      string
+		substr string
+	}{
+		{"hello world", "world"},
+		{"", ""},
+		{"hello", ""},
+		{"", "x"},
+		{"hello", "world"},
+		{"ababab", "ab"},
+	}
+
+	for _, tc := range testCases {
+		ourResult := containsSubstring(tc.s, tc.substr)
+		stdResult := strings.Contains(tc.s, tc.substr)
+		if ourResult != stdResult {
+			t.Errorf("containsSubstring(%q, %q) = %v, strings.Contains = %v",
+				tc.s, tc.substr, ourResult, stdResult)
+		}
+	}
+}