feat(provider): expose verifier error sentinels for errors.Is discrimination (#577)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: stan-is-hate

provider/errors.go

@@ -0,0 +1,21 @@
+package provider
+
+import "github.com/pact-foundation/pact-go/v2/internal/native"
+
+// Sentinel errors returned by Verifier.VerifyProvider so callers can
+// discriminate between a verification mismatch and an infrastructure failure
+// of the verifier itself. Pact-go publishes verification results to the broker
+// before returning ErrVerificationFailed (when PublishVerificationResults is
+// enabled), so callers that gate via can-i-merge / can-i-deploy can choose to
+// treat verification mismatches as non-fatal at the test step.
+var (
+	// ErrVerificationFailed is returned when one or more consumer pact
+	// verifications did not match the provider's responses. Verification
+	// results are published to the broker before this error is returned.
+	ErrVerificationFailed = native.ErrVerifierFailed
+
+	// ErrVerifierFailedToRun is returned when the verifier could not execute
+	// at all — typically an infrastructure, configuration, or framework
+	// problem. No verification results were published.
+	ErrVerifierFailedToRun = native.ErrVerifierFailedToRun
+)

provider/errors_test.go

@@ -0,0 +1,42 @@
+package provider
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/pact-foundation/pact-go/v2/internal/native"
+)
+
+// TestErrVerificationFailed_IsNativeSentinel guards the re-export: the
+// public provider.ErrVerificationFailed must remain identical to the
+// internal/native sentinel so callers can use errors.Is to discriminate
+// the error returned by Verifier.VerifyProvider.
+func TestErrVerificationFailed_IsNativeSentinel(t *testing.T) {
+	if !errors.Is(ErrVerificationFailed, native.ErrVerifierFailed) {
+		t.Errorf("ErrVerificationFailed must be the same sentinel as internal/native.ErrVerifierFailed")
+	}
+	if !errors.Is(ErrVerifierFailedToRun, native.ErrVerifierFailedToRun) {
+		t.Errorf("ErrVerifierFailedToRun must be the same sentinel as internal/native.ErrVerifierFailedToRun")
+	}
+}
+
+// TestErrVerificationFailed_DiscriminatesFromGenericError makes sure the
+// sentinels are not confused with arbitrary error values.
+func TestErrVerificationFailed_DiscriminatesFromGenericError(t *testing.T) {
+	generic := fmt.Errorf("something else broke")
+	if errors.Is(generic, ErrVerificationFailed) {
+		t.Error("generic error should not match ErrVerificationFailed")
+	}
+	if errors.Is(generic, ErrVerifierFailedToRun) {
+		t.Error("generic error should not match ErrVerifierFailedToRun")
+	}
+}
+
+// TestErrVerificationFailed_DistinctFromEachOther ensures the two sentinels
+// are not interchangeable.
+func TestErrVerificationFailed_DistinctFromEachOther(t *testing.T) {
+	if errors.Is(ErrVerificationFailed, ErrVerifierFailedToRun) {
+		t.Error("ErrVerificationFailed and ErrVerifierFailedToRun must be distinct")
+	}
+}