package main

import (
	"context"
	"fmt"
	"net/http"
	"time"

	"github.com/drykit-go/testx"
	"github.com/drykit-go/testx/check"
)

func main() {
	// withLongProcess middleware processes something for 100 milliseconds.
	withLongProcess := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			time.Sleep(100 * time.Millisecond)
			next.ServeHTTP(w, r)
		})
	}

	// withContextValue middleware attaches the input key-val pair
	// to the request context.
	withContextValue := func(key, val interface{}) func(http.Handler) http.Handler {
		return func(next http.Handler) http.Handler {
			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				ctx := context.WithValue(r.Context(), key, val)
				next.ServeHTTP(w, r.WithContext(ctx))
			})
		}
	}

	// withContentType middleware sets the response header Content-Type
	// to contentType.
	withContentType := func(contentType string) func(http.Handler) http.Handler {
		return func(next http.Handler) http.Handler {
			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set("Content-Type", contentType)
				next.ServeHTTP(w, r)
			})
		}
	}

	results := testx.HTTPHandler(nil, // nil is interpreted as a no-op handler
		withLongProcess,
		withContextValue("userID", 42),
		withContentType("application/json"),
	).
		Duration(check.Duration.Over(100 * time.Millisecond)).
		Request(check.HTTPRequest.Context(check.Context.HasKeys("userID"))).
		Response(check.HTTPResponse.Header(check.HTTPHeader.HasValue("application/json"))).
		DryRun()

	fmt.Println(results.Passed())

}

Output:

true

package main

import (
	"net/http"
	"testing"
	"time"

	"github.com/drykit-go/testx"
	"github.com/drykit-go/testx/check"
)

func MyHTTPHandler(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	if id != "42" {
		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
		return
	}
	time.Sleep(500 * time.Millisecond)
	w.Write([]byte("ok"))
}

func main() {
	t := &testing.T{} // ignore: emulating a testing context

	t.Run("good request", func(t *testing.T) {
		r, _ := http.NewRequest("GET", "/endpoint?id=42", nil)
		testx.HTTPHandlerFunc(MyHTTPHandler).WithRequest(r).
			Response(
				check.HTTPResponse.StatusCode(check.Int.InRange(200, 299)),
				check.HTTPResponse.Body(check.Bytes.Is([]byte("ok"))),
			).
			Run(t)
	})

	t.Run("bad request", func(t *testing.T) {
		r, _ := http.NewRequest("GET", "/endpoint?id=404", nil)
		testx.HTTPHandlerFunc(MyHTTPHandler).WithRequest(r).
			Response(check.HTTPResponse.Status(check.String.Contains("Not Found"))).
			Duration(check.Duration.Under(10 * time.Millisecond)).
			Run(t)
	})
}

Output:

package main

import (
	"fmt"
	"net/http"
	"time"

	"github.com/drykit-go/testx"
	"github.com/drykit-go/testx/check"
)

func MyHTTPHandler(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	if id != "42" {
		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
		return
	}
	time.Sleep(500 * time.Millisecond)
	w.Write([]byte("ok"))
}

func main() {
	handlerRunner := testx.HTTPHandlerFunc(MyHTTPHandler)

	goodRequest, _ := http.NewRequest("GET", "/endpoint?id=42", nil)
	goodRequestResults := handlerRunner.WithRequest(goodRequest).
		Response(
			check.HTTPResponse.StatusCode(check.Int.InRange(200, 299)),
			check.HTTPResponse.Body(check.Bytes.Is([]byte("ok"))),
		).
		DryRun()

	badRequest, _ := http.NewRequest("GET", "/endpoint?id=404", nil)
	badRequestResults := handlerRunner.WithRequest(badRequest).
		Response(check.HTTPResponse.Status(check.String.Contains("Not Found"))).
		Duration(check.Duration.Under(10 * time.Millisecond)).
		DryRun()

	fmt.Println(goodRequestResults.Passed())
	fmt.Println(goodRequestResults.ResponseStatus())
	fmt.Println(badRequestResults.Passed())
	fmt.Println(badRequestResults.ResponseStatus())

}

Output:

true
200 OK
true
404 Not Found

package main

import (
	"errors"
	"testing"

	"github.com/drykit-go/testx"
)

func main() {
	t := &testing.T{} // ignore: emulating a testing context

	// divide is the func to be tested.
	// It returns x/y or a non-nil error if y == 0
	divide := func(x, y float64) (float64, error) {
		if y == 0 {
			return 0, errors.New("division by 0")
		}
		return x / y, nil
	}

	// func divide has several parameters and return values,
	// so we specify a config to determinate:
	// - at which param position Case.In is injected
	// - the values used for the other arguments (fixed for all cases)
	// - which return value we want to compare Case.Exp with
	//
	// In this example, we check the error value of divide (return value
	// at position 1).
	// We inject Case.In at position 1 (param y) and use a fixed value
	// of 42.0 at position 0 (param x) for all cases.
	testx.Table(divide).Config(testx.TableConfig{
		// Positions start at 0
		InPos:     1,                      // Case.In injected in param position 1 (y)
		OutPos:    1,                      // Case.Exp compared to return value position 1 (error value)
		FixedArgs: []interface{}{0: 42.0}, // param 0 (x) set to 42.0 for all cases
	}).Cases([]testx.Case{
		{In: 1.0, Exp: testx.ExpNil},                // divide(42.0, 1.0) -> (_, nil)
		{In: 0.0, Exp: errors.New("division by 0")}, // divide(42.0, 0.0) -> (_, err)
	}).Run(t)
}

Output:

package main

import (
	"testing"

	"github.com/drykit-go/testx"
	"github.com/drykit-go/testx/check"
	"github.com/drykit-go/testx/checkconv"
)

func main() {
	t := &testing.T{} // ignore: emulating a testing context

	// double is the func to be tested.
	double := func(x float64) float64 { return 2 * x }

	// func double has 1 parameter and 1 return value,
	// hence no config is needed
	testx.Table(double).Cases([]testx.Case{
		{In: 0.0, Exp: 0.0},
		{In: -2.0, Pass: checkconv.AssertMany(check.Float64.InRange(-5, -3))},
	}).Run(t)
}

Output: