Add Succeed Matcher

CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index faad006..ea269ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@
 - `Receive()` no longer errors when passed a closed channel, it's perfectly fine to attempt to read from a closed channel so Ω(c).Should(Receive()) always fails and Ω(c).ShoudlNot(Receive()) always passes with a closed channel.
 - Added `HavePrefix` and `HaveSuffix` matchers.
 - `ghttp` can now handle concurrent requests.
+- Added `Succeed` which allows one to write `Ω(MyFunction()).Should(Succeed())`.
 
 ## 1.0 (8/2/2014)
 

matchers.go

diff --git a/matchers.go b/matchers.go
index 708e697..307f88a 100644
--- a/matchers.go
+++ b/matchers.go
@@ -49,6 +49,21 @@
 	return &matchers.HaveOccurredMatcher{}
 }
 
+//Succeed passes if actual is a nil error
+//Succeed is intended to be used with functions that return a single error value. Instead of
+//    err := SomethingThatMightFail()
+//    Ω(err).ShouldNot(HaveOccurred())
+//
+//You can write:
+//    Ω(SomethingThatMightFail()).Should(Succeed())
+//
+//It is a mistake to use Succeed with a function that has multiple return values.  Gomega's Ω and Expect
+//functions automatically trigger failure if any return values after the first return value are non-zero/non-nil.
+//This means that Ω(MultiReturnFunc()).ShouldNot(Succeed()) can never pass.
+func Succeed() types.GomegaMatcher {
+	return &matchers.SucceedMatcher{}
+}
+
 //MatchError succeeds if actual is a non-nil error that matches the passed in string/error.
 //
 //These are valid use-cases:

matchers/succeed_matcher.go

diff --git a/matchers/succeed_matcher.go b/matchers/succeed_matcher.go
new file mode 100644
index 0000000..c162b67
--- /dev/null
+++ b/matchers/succeed_matcher.go
@@ -0,0 +1,30 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type SucceedMatcher struct {
+}
+
+func (matcher *SucceedMatcher) Match(actual interface{}) (success bool, err error) {
+	if actual == nil {
+		return true, nil
+	}
+
+	if isError(actual) {
+		return false, nil
+	}
+
+	return false, fmt.Errorf("Expected an error-type.  Got:\n%s", format.Object(actual, 1))
+}
+
+func (matcher *SucceedMatcher) FailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected success, but got an error:\n%s", format.Object(actual, 1))
+}
+
+func (matcher *SucceedMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return "Expected failure, but got no error."
+}

matchers/succeed_matcher_test.go

diff --git a/matchers/succeed_matcher_test.go b/matchers/succeed_matcher_test.go
new file mode 100644
index 0000000..3562e70
--- /dev/null
+++ b/matchers/succeed_matcher_test.go
@@ -0,0 +1,39 @@
+package matchers_test
+
+import (
+	"errors"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+func Erroring() error {
+	return errors.New("bam")
+}
+
+func NotErroring() error {
+	return nil
+}
+
+type AnyType struct{}
+
+func Invalid() *AnyType {
+	return nil
+}
+
+var _ = Describe("Succeed", func() {
+	It("should succeed if the function succeeds", func() {
+		Ω(NotErroring()).Should(Succeed())
+	})
+
+	It("should succeed (in the negated) if the function errored", func() {
+		Ω(Erroring()).ShouldNot(Succeed())
+	})
+
+	It("should not if passed a non-error", func() {
+		success, err := (&SucceedMatcher{}).Match(Invalid())
+		Ω(success).Should(BeFalse())
+		Ω(err).Should(HaveOccurred())
+	})
+})