318 lines
7.3 KiB
Go
318 lines
7.3 KiB
Go
package http
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"forge.cadoles.com/cadoles/bouncer/internal/rule"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
func TestAddResponseHeader(t *testing.T) {
|
|
type Vars struct {
|
|
NewHeaderKey string `expr:"newHeaderKey"`
|
|
NewHeaderValue string `expr:"newHeaderValue"`
|
|
}
|
|
|
|
engine := createRuleEngine[Vars](t,
|
|
rule.WithExpr(addResponseHeaderFunc()),
|
|
rule.WithRules(
|
|
"add_header(ctx, vars.newHeaderKey, vars.newHeaderValue)",
|
|
),
|
|
)
|
|
|
|
req, err := http.NewRequest("GET", "http://example.net", nil)
|
|
if err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
resp := createResponse(req, http.StatusOK, nil)
|
|
|
|
ctx := context.Background()
|
|
|
|
ctx = WithResponse(ctx, resp)
|
|
|
|
vars := Vars{
|
|
NewHeaderKey: "X-My-Header",
|
|
NewHeaderValue: "foobar",
|
|
}
|
|
|
|
if _, err := engine.Apply(ctx, vars); err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
if e, g := vars.NewHeaderValue, resp.Header.Get(vars.NewHeaderKey); e != g {
|
|
t.Errorf("resp.Header.Get(vars.NewHeaderKey): expected '%v', got '%v'", e, g)
|
|
}
|
|
}
|
|
|
|
func TestResponseSetHeader(t *testing.T) {
|
|
type Vars struct {
|
|
HeaderKey string `expr:"headerKey"`
|
|
HeaderValue string `expr:"headerValue"`
|
|
}
|
|
|
|
engine := createRuleEngine[Vars](t,
|
|
rule.WithExpr(setResponseHeaderFunc()),
|
|
rule.WithRules(
|
|
"set_header(ctx, vars.headerKey, vars.headerValue)",
|
|
),
|
|
)
|
|
|
|
req, err := http.NewRequest("GET", "http://example.net", nil)
|
|
if err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
resp := createResponse(req, http.StatusOK, nil)
|
|
|
|
vars := Vars{
|
|
HeaderKey: "X-My-Header",
|
|
HeaderValue: "foobar",
|
|
}
|
|
|
|
resp.Header.Set(vars.HeaderKey, "test")
|
|
|
|
ctx := context.Background()
|
|
ctx = WithResponse(ctx, resp)
|
|
|
|
if _, err := engine.Apply(ctx, vars); err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
if e, g := vars.HeaderValue, resp.Header.Get(vars.HeaderKey); e != g {
|
|
t.Errorf("resp.Header.Get(vars.HeaderKey): expected '%v', got '%v'", e, g)
|
|
}
|
|
}
|
|
|
|
func TestResponseDelHeaders(t *testing.T) {
|
|
type Vars struct {
|
|
HeaderPattern string `expr:"headerPattern"`
|
|
}
|
|
|
|
engine := createRuleEngine[Vars](t,
|
|
rule.WithExpr(delResponseHeadersFunc()),
|
|
rule.WithRules(
|
|
"del_headers(ctx, vars.headerPattern)",
|
|
),
|
|
)
|
|
|
|
req, err := http.NewRequest("GET", "http://example.net", nil)
|
|
if err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
resp := createResponse(req, http.StatusOK, nil)
|
|
|
|
vars := Vars{
|
|
HeaderPattern: "X-My-*",
|
|
}
|
|
|
|
resp.Header.Set("X-My-Header", "test")
|
|
|
|
ctx := context.Background()
|
|
ctx = WithResponse(ctx, resp)
|
|
|
|
if _, err := engine.Apply(ctx, vars); err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
if val := resp.Header.Get("X-My-Header"); val != "" {
|
|
t.Errorf("resp.Header.Get(\"X-My-Header\") should be empty, got '%v'", val)
|
|
}
|
|
}
|
|
|
|
func TestAddResponseCookie(t *testing.T) {
|
|
type TestCase struct {
|
|
Cookie map[string]any
|
|
Check func(t *testing.T, tc TestCase, res *http.Response)
|
|
ShouldFail bool
|
|
}
|
|
|
|
testCases := []TestCase{
|
|
{
|
|
Cookie: map[string]any{
|
|
"name": "foo",
|
|
"value": "test",
|
|
"domain": "example.net",
|
|
"path": "/custom",
|
|
"same_site": http.SameSiteStrictMode,
|
|
"http_only": true,
|
|
"secure": false,
|
|
"expires": time.Now().UTC().Truncate(time.Second),
|
|
},
|
|
Check: func(t *testing.T, tc TestCase, res *http.Response) {
|
|
var cookie *http.Cookie
|
|
for _, c := range res.Cookies() {
|
|
if c.Name == tc.Cookie["name"] {
|
|
cookie = c
|
|
break
|
|
}
|
|
}
|
|
if cookie == nil {
|
|
t.Errorf("could not find cookie '%s'", tc.Cookie["name"])
|
|
return
|
|
}
|
|
|
|
if e, g := tc.Cookie["name"], cookie.Name; e != g {
|
|
t.Errorf("cookie.Name: expected '%v', got '%v'", e, g)
|
|
}
|
|
|
|
if e, g := tc.Cookie["value"], cookie.Value; e != g {
|
|
t.Errorf("cookie.Value: expected '%v', got '%v'", e, g)
|
|
}
|
|
|
|
if e, g := tc.Cookie["domain"], cookie.Domain; e != g {
|
|
t.Errorf("cookie.Domain: expected '%v', got '%v'", e, g)
|
|
}
|
|
|
|
if e, g := tc.Cookie["path"], cookie.Path; e != g {
|
|
t.Errorf("cookie.Path: expected '%v', got '%v'", e, g)
|
|
}
|
|
|
|
if e, g := tc.Cookie["secure"], cookie.Secure; e != g {
|
|
t.Errorf("cookie.Secure: expected '%v', got '%v'", e, g)
|
|
}
|
|
|
|
if e, g := tc.Cookie["http_only"], cookie.HttpOnly; e != g {
|
|
t.Errorf("cookie.HttpOnly: expected '%v', got '%v'", e, g)
|
|
}
|
|
|
|
if e, g := tc.Cookie["same_site"], cookie.SameSite; e != g {
|
|
t.Errorf("cookie.SameSite: expected '%v', got '%v'", e, g)
|
|
}
|
|
|
|
if e, g := tc.Cookie["expires"], cookie.Expires; e != g {
|
|
t.Errorf("cookie.Expires: expected '%v', got '%v'", e, g)
|
|
}
|
|
},
|
|
},
|
|
{
|
|
Cookie: map[string]any{
|
|
"name": "foo",
|
|
"expires": time.Now().UTC().Format(http.TimeFormat),
|
|
},
|
|
Check: func(t *testing.T, tc TestCase, res *http.Response) {
|
|
var cookie *http.Cookie
|
|
for _, c := range res.Cookies() {
|
|
if c.Name == tc.Cookie["name"] {
|
|
cookie = c
|
|
break
|
|
}
|
|
}
|
|
if cookie == nil {
|
|
t.Errorf("could not find cookie '%s'", tc.Cookie["name"])
|
|
return
|
|
}
|
|
|
|
if e, g := tc.Cookie["expires"], cookie.Expires.Format(http.TimeFormat); e != g {
|
|
t.Errorf("cookie.Expires: expected '%v', got '%v'", e, g)
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for idx, tc := range testCases {
|
|
t.Run(fmt.Sprintf("Case_%d", idx), func(t *testing.T) {
|
|
type Vars struct {
|
|
NewCookie map[string]any `expr:"new_cookie"`
|
|
}
|
|
|
|
engine := createRuleEngine[Vars](t,
|
|
rule.WithExpr(addResponseCookieFunc()),
|
|
rule.WithRules(
|
|
`add_cookie(ctx, vars.new_cookie)`,
|
|
),
|
|
)
|
|
|
|
req, err := http.NewRequest("GET", "http://example.net", nil)
|
|
if err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
resp := createResponse(req, http.StatusOK, nil)
|
|
|
|
vars := Vars{
|
|
NewCookie: tc.Cookie,
|
|
}
|
|
|
|
ctx := context.Background()
|
|
ctx = WithRequest(ctx, req)
|
|
ctx = WithResponse(ctx, resp)
|
|
|
|
if _, err := engine.Apply(ctx, vars); err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
if tc.ShouldFail {
|
|
t.Error("engine.Apply() should have failed")
|
|
}
|
|
|
|
if tc.Check != nil {
|
|
tc.Check(t, tc, resp)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetResponseCookie(t *testing.T) {
|
|
type Vars struct {
|
|
CookieName string `expr:"cookieName"`
|
|
}
|
|
|
|
engine := createRuleEngine[Vars](t,
|
|
rule.WithExpr(getResponseCookieFunc()),
|
|
rule.WithRules(
|
|
"let cookie = get_cookie(ctx, vars.cookieName); cookie.value",
|
|
),
|
|
)
|
|
|
|
req, err := http.NewRequest("GET", "http://example.net", nil)
|
|
if err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
resp := createResponse(req, http.StatusOK, nil)
|
|
|
|
vars := Vars{
|
|
CookieName: "foo",
|
|
}
|
|
|
|
cookie := &http.Cookie{
|
|
Name: vars.CookieName,
|
|
Value: "bar",
|
|
}
|
|
|
|
resp.Header.Add("Set-Cookie", cookie.String())
|
|
|
|
ctx := context.Background()
|
|
ctx = WithResponse(ctx, resp)
|
|
|
|
results, err := engine.Apply(ctx, vars)
|
|
if err != nil {
|
|
t.Fatalf("%+v", errors.WithStack(err))
|
|
}
|
|
|
|
if e, g := cookie.Value, results[0]; e != g {
|
|
t.Errorf("result[0]: expected '%v', got '%v'", e, g)
|
|
}
|
|
}
|
|
|
|
func createResponse(req *http.Request, statusCode int, body io.Reader) *http.Response {
|
|
return &http.Response{
|
|
Status: http.StatusText(statusCode),
|
|
StatusCode: statusCode,
|
|
Proto: "HTTP/1.1",
|
|
ProtoMajor: 1,
|
|
ProtoMinor: 1,
|
|
Body: io.NopCloser(body),
|
|
ContentLength: -1,
|
|
Request: req,
|
|
Header: make(http.Header, 0),
|
|
}
|
|
}
|