271 lines
7.2 KiB
Go
271 lines
7.2 KiB
Go
package hws_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"git.haelnorr.com/h/golib/hws"
|
|
"github.com/pkg/errors"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type (
|
|
goodPage struct{}
|
|
badPage struct{}
|
|
)
|
|
|
|
func goodRender(error hws.HWSError) (hws.ErrorPage, error) {
|
|
return goodPage{}, nil
|
|
}
|
|
|
|
func badRender1(error hws.HWSError) (hws.ErrorPage, error) {
|
|
return badPage{}, nil
|
|
}
|
|
|
|
func badRender2(error hws.HWSError) (hws.ErrorPage, error) {
|
|
return nil, errors.New("I'm an error")
|
|
}
|
|
|
|
func (g goodPage) Render(ctx context.Context, w io.Writer) error {
|
|
_, err := w.Write([]byte("Test write to ResponseWriter"))
|
|
return err
|
|
}
|
|
|
|
func (b badPage) Render(ctx context.Context, w io.Writer) error {
|
|
return nil
|
|
}
|
|
|
|
func Test_AddErrorPage(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
server := createTestServer(t, &buf)
|
|
|
|
goodRender := goodRender
|
|
badRender1 := badRender1
|
|
badRender2 := badRender2
|
|
|
|
tests := []struct {
|
|
name string
|
|
renderer hws.ErrorPageFunc
|
|
valid bool
|
|
}{
|
|
{
|
|
name: "Valid Renderer",
|
|
renderer: goodRender,
|
|
valid: true,
|
|
},
|
|
{
|
|
name: "Invalid Renderer 1",
|
|
renderer: badRender1,
|
|
valid: false,
|
|
},
|
|
{
|
|
name: "Invalid Renderer 2",
|
|
renderer: badRender2,
|
|
valid: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := server.AddErrorPage(tt.renderer)
|
|
if tt.valid {
|
|
assert.NoError(t, err)
|
|
} else {
|
|
assert.Error(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_ThrowError(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
server := createTestServer(t, &buf)
|
|
rr := httptest.NewRecorder()
|
|
|
|
req := httptest.NewRequest("GET", "/", nil)
|
|
|
|
t.Run("Server not started", func(t *testing.T) {
|
|
buf.Reset()
|
|
server.ThrowError(rr, req, hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "Error",
|
|
Error: errors.New("Error"),
|
|
})
|
|
// ThrowError logs errors internally when validation fails
|
|
output := buf.String()
|
|
assert.Contains(t, output, "ThrowError called before server started")
|
|
})
|
|
|
|
startTestServer(t, server)
|
|
|
|
tests := []struct {
|
|
name string
|
|
request *http.Request
|
|
error hws.HWSError
|
|
expectLogItem string
|
|
}{
|
|
{
|
|
name: "No HWSError.Status code",
|
|
request: nil,
|
|
error: hws.HWSError{},
|
|
expectLogItem: "HWSError.StatusCode cannot be 0",
|
|
},
|
|
{
|
|
name: "Negative HWSError.Status code",
|
|
request: nil,
|
|
error: hws.HWSError{StatusCode: -1},
|
|
expectLogItem: "HWSError.StatusCode cannot be 0",
|
|
},
|
|
{
|
|
name: "No HWSError.Message",
|
|
request: nil,
|
|
error: hws.HWSError{StatusCode: http.StatusInternalServerError},
|
|
expectLogItem: "HWSError.Message cannot be empty",
|
|
},
|
|
{
|
|
name: "No HWSError.Error",
|
|
request: nil,
|
|
error: hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
},
|
|
expectLogItem: "HWSError.Error cannot be nil",
|
|
},
|
|
{
|
|
name: "No request provided",
|
|
request: nil,
|
|
error: hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
},
|
|
expectLogItem: "Request cannot be nil",
|
|
},
|
|
{
|
|
name: "Valid",
|
|
request: httptest.NewRequest("GET", "/", nil),
|
|
error: hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
},
|
|
expectLogItem: "An error occured",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
buf.Reset()
|
|
rr := httptest.NewRecorder()
|
|
server.ThrowError(rr, tt.request, tt.error)
|
|
// ThrowError no longer returns errors; check logs instead
|
|
output := buf.String()
|
|
assert.Contains(t, output, tt.expectLogItem)
|
|
})
|
|
}
|
|
t.Run("Log level set correctly", func(t *testing.T) {
|
|
buf.Reset()
|
|
rr := httptest.NewRecorder()
|
|
req := httptest.NewRequest("GET", "/", nil)
|
|
server.ThrowError(rr, req, hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
Level: hws.ErrorWARN,
|
|
})
|
|
_, err := buf.ReadString([]byte(" ")[0])
|
|
require.NoError(t, err)
|
|
loglvl, err := buf.ReadString([]byte(" ")[0])
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "\x1b[33mWRN\x1b[0m ", loglvl, "Log level should be WRN for ErrorWARN")
|
|
|
|
buf.Reset()
|
|
server.ThrowError(rr, req, hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
})
|
|
_, err = buf.ReadString([]byte(" ")[0])
|
|
require.NoError(t, err)
|
|
loglvl, err = buf.ReadString([]byte(" ")[0])
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "\x1b[31mERR\x1b[0m ", loglvl, "Log level should be ERR when no level specified")
|
|
})
|
|
|
|
t.Run("Error page doesnt render if no error page set", func(t *testing.T) {
|
|
// Must be run before adding the error page to the test server
|
|
rr := httptest.NewRecorder()
|
|
req := httptest.NewRequest("GET", "/", nil)
|
|
server.ThrowError(rr, req, hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
RenderErrorPage: true,
|
|
})
|
|
body := rr.Body.String()
|
|
assert.Empty(t, body, "Error page should not render when no error page is set")
|
|
})
|
|
t.Run("Error page renders", func(t *testing.T) {
|
|
rr := httptest.NewRecorder()
|
|
req := httptest.NewRequest("GET", "/", nil)
|
|
// Adding the error page will carry over to all future tests and cant be undone
|
|
err := server.AddErrorPage(goodRender)
|
|
require.NoError(t, err)
|
|
server.ThrowError(rr, req, hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
RenderErrorPage: true,
|
|
})
|
|
body := rr.Body.String()
|
|
assert.NotEmpty(t, body, "Error page should render when RenderErrorPage is true")
|
|
})
|
|
t.Run("Error page doesnt render if not told to render", func(t *testing.T) {
|
|
// Error page already added to server
|
|
rr := httptest.NewRecorder()
|
|
req := httptest.NewRequest("GET", "/", nil)
|
|
server.ThrowError(rr, req, hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
})
|
|
body := rr.Body.String()
|
|
assert.Empty(t, body, "Error page should not render when RenderErrorPage is false")
|
|
})
|
|
err := server.Shutdown(t.Context())
|
|
require.NoError(t, err)
|
|
|
|
t.Run("Doesn't panic if no logger added to server", func(t *testing.T) {
|
|
server, err := hws.NewServer(&hws.Config{
|
|
Host: "127.0.0.1",
|
|
Port: randomPort(),
|
|
})
|
|
require.NoError(t, err)
|
|
err = server.AddRoutes(hws.Route{
|
|
Path: "/",
|
|
Method: hws.MethodGET,
|
|
Handler: testHandler,
|
|
})
|
|
require.NoError(t, err)
|
|
err = server.Start(t.Context())
|
|
require.NoError(t, err)
|
|
<-server.Ready()
|
|
|
|
rr := httptest.NewRecorder()
|
|
req := httptest.NewRequest("GET", "/", nil)
|
|
// Should not panic when no logger is present
|
|
assert.NotPanics(t, func() {
|
|
server.ThrowError(rr, req, hws.HWSError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Message: "An error occured",
|
|
Error: errors.New("Error"),
|
|
})
|
|
}, "ThrowError should not panic when no logger is present")
|
|
err = server.Shutdown(t.Context())
|
|
require.NoError(t, err)
|
|
})
|
|
}
|