expectto/be is a Golang package that offers a substantial collection of Be matchers. Every Be matcher is compatible with both Ginkgo/Gomega and Gomock. Where possible, arguments of matchers can be either finite values or matchers (Be/Gomega/Gomock).
Employing expectto/be matchers enables you to create straightforward, readable, and maintainable unit or integration tests in Golang. Tasks such as testing HTTP requests, validating JSON responses, and more become remarkably comprehensive and straightforward.

• Installation

• Example

• Matchers

  • Be (core)
  • Be Reflected
  • Be Math
  • Be String
  • Be Time
  • Be JWT
  • Be URL
  • Be JSON
  • Be HTTP

• Contributing

• License

To use Be in your Golang project, simply import it:

import "github.com/expectto/be"

Consider the following example demonstrating the usage of expectto/be's HTTP request matchers:

req, err := buildRequestForServiceFoo()
Expect(err).To(Succeed())

// Matching an HTTP request
Expect(req).To(be_http.Request(
    // Matching the URL
    be_http.HavingURL(be_url.URL(
        be_url.WithHttps(),
        be_url.HavingHost("example.com"),
        be_url.HavingPath("/path"),
        be_url.HavingSearchParam("status", "active"),
        be_url.HavingSearchParam("v", be_reflected.AsNumericString()),
        be_url.HavingSearchParam("q", "Hello World"),
    )),

    // Matching the HTTP method
    be_http.POST()

    // Matching request's context
    be_http.HavingCtx(be_ctx.Ctx(
        be_ctx.WithDeadline(be_time.LaterThan(time.Now().Add(30*time.Minute))),
        be_ctx.WithValue("foobar", 100),
    )),

    // Matching the request body using JSON matchers
    be_http.HavingBody(
        be_json.Matcher(
            be_json.JsonAsReader,
            be_json.HaveKeyValue("hello", "world"),
            be_json.HaveKeyValue("n", be_reflected.AsInteger()),
            be_json.HaveKeyValue("ids", be_reflected.AsSliceOf[string]),
            be_json.HaveKeyValue("details", And(
                be_reflected.AsObjects(),
                be.HaveLength(2),
                ContainElements(
                    be_json.HaveKeyValue("key", "foo"),
                    be_json.HaveKeyValue("key", "bar"),
                ),
            )),
        ),

        // Matching HTTP headers
        be_http.HavingHeader("X-Custom", "Hey-There"),
        be_http.HavingHeader("Authorization",
            be_string.MatchTemplate("Bearer {{jwt}}",
                be_string.Var("jwt",
                    be_jwt.Token(
                        be_jwt.Valid(),
                        be_jwt.HavingClaim("name", "John Doe"),
                    ),
                ),
            ),
        ),
    ),
))      

📦 be provides a set of core matchers for common testing scenarios.
See detailed docs

Always, Never, All, Any, Eq, Not, HaveLength, Dive, DiveAny, DiveFirst

📦 be_reflected provides Be matchers that use reflection, enabling expressive assertions on values' reflect kinds and types.
See detailed docs

AsKind, AsFunc, AsChan, AsPointer, AsFinalPointer, AsStruct, AsPointerToStruct, AsSlice, AsPointerToSlice, AsSliceOf, AsMap, AsPointerToMap, AsObject, AsObjects, AsPointerToObject

AsString, AsBytes, AsNumeric, AsNumericString, AsInteger, AsIntegerString, AsFloat, AsFloatishString,

AsReader,AsStringer

AssignableTo, Implementing

📦 be_math provides Be matchers for mathematical operations.
See detailed docs

GreaterThan, GreaterThanEqual, LessThan, LessThanEqual, Approx, InRange, Odd, Even, Negative, Positive, Zero, Integral, DivisibleBy

Gt, Gte, Lt, Lte

📦 be_string provides Be matchers for string-related assertions.
See detailed docs

NonEmptyString, EmptyString, Alpha, Numeric, AlphaNumeric, AlphaNumericWithDots, Float, Titled, LowerCaseOnly, MatchWildcard, ValidEmail

MatchTemplate

📦 be_time provides Be matchers on time.Time.
See detailed docs

LaterThan, LaterThanEqual, EarlierThan, EarlierThanEqual, Eq, Approx,
SameExactMilli, SameExactSecond, SameExactMinute, SameExactHour,
SameExactDay, SameExactWeekday, SameExactWeek, SameExactMonth,
SameSecond, SameMinute, SameHour, SameDay, SameYearDay,
SameWeek, SameMonth, SameYear, SameTimzone, SameOffset, IsDST

📦 be_jwt provides Be matchers for handling JSON Web Tokens (JWT). It includes matchers for transforming and validating JWT tokens. Matchers corresponds to specific golang jwt implementation.
See detailed docs

TransformSignedJwtFromString, TransformJwtFromString

Token, Valid, HavingClaims, HavingClaim, HavingMethodAlg, SignedVia

📦 be_url provides Be matchers on url.URL.
See detailed docs

TransformUrlFromString, TransformSchemelessUrlFromString

URL, HavingHost, HavingHostname, HavingScheme, NotHavingScheme, WithHttps, WithHttp, HavingPort, NotHavingPort, HavingPath, HavingRawQuery, HavingSearchParam, HavingMultipleSearchParam, HavingUsername, HavingUserinfo, HavingPassword

📦 be_ctx provides Be matchers on context.Context.
See detailed docs

Ctx, CtxWithValue, CtxWithDeadline, CtxWithError

📦 be_json provides Be matchers for expressive assertions on JSON.
See detailed docs

Matcher, HaveKeyValue

📦 be_http provides Be matchers for expressive assertions on http.Request.
See detailed docs

Request, HavingMethod,
GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, CONNECT, TRACE,
HavingURL, HavingBody, HavingHost, HavingProto, HavingHeader, HavingHeaders

Be welcomes contributions! Feel free to open issues, suggest improvements, or submit pull requests. Contribution guidelines for this project

This project is licensed under the MIT License.