Skip to content

Lightweight server monitoring with historical data, docker stats, and alerts.

5.7 KB
Raw Blame
//go:build testing

package users_test

import (
	"errors"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"ganigeorgiev.com/pocketbase/pocketbase/core"
	"ganigeorgiev.com/pocketbase/pocketbase/tools/router"
	"github.com/henrygd/beszel/internal/migrations"
	beszelTests "github.com/henrygd/beszel/internal/tests"
	"github.com/henrygd/beszel/internal/users"
	"github.com/stretchr/testify/require"
)

func TestCreateFirstUserPasswordMaxLength(t *testing.T) {
	newHub := func(t *testing.T) (*beszelTests.TestHub, func(string) (int, string)) {
		h, err := beszelTests.NewTestHub(t.TempDir())
		require.NoError(t, err)
		h.StartHub()
		um := users.NewUserManager(h.App)
		return h, func(password string) (int, string) {
			req := httptest.NewRequest("POST", "/api/beszel/create-user",
				strings.NewReader(`{"email":"[email protected]","password":"`+password+`"}`))
			req.Header.Set("Content-Type", "application/json")
			res := httptest.NewRecorder()
			require.NoError(t, um.CreateFirstUser(&core.RequestEvent{App: h.App, Event: router.Event{Request: req, Response: res}}))
			return res.Code, res.Body.String()
		}
	}

	t.Run("72 chars exceeds the PocketBase field max and 500s", func(t *testing.T) {
		h, invoke := newHub(t)
		defer h.Cleanup()
		status, body := invoke(strings.Repeat("a", 72))
		require.Equal(t, http.StatusInternalServerError, status)
		require.Contains(t, body, "Must be less than 71 character(s)")
	})

	t.Run("71 chars succeeds", func(t *testing.T) {
		h, invoke := newHub(t)
		defer h.Cleanup()
		status, body := invoke(strings.Repeat("a", 71))
		require.Equal(t, http.StatusOK, status)
		require.Contains(t, body, "User created")
	})

	// 37 'é' runes = 37 characters but 74 bytes in UTF-8: it passes the
	// 71-character field max, then bcrypt rejects passwords over 72 bytes.
	t.Run("37 multibyte chars (74 bytes) exceeds the bcrypt limit", func(t *testing.T) {
		h, invoke := newHub(t)
		defer h.Cleanup()
		status, body := invoke(strings.Repeat("é", 37))
		require.Equal(t, http.StatusBadRequest, status)
		require.Contains(t, body, "must be less than 72 bytes")
	})

	// 36 'é' runes = 72 bytes exactly: still within the bcrypt limit.
	t.Run("36 multibyte chars (exactly 72 bytes) succeeds", func(t *testing.T) {
		h, invoke := newHub(t)
		defer h.Cleanup()
		status, body := invoke(strings.Repeat("é", 36))
		require.Equal(t, http.StatusOK, status)
		require.Contains(t, body, "User created")
	})
}

type blockedBody struct {
	io.Reader
	entered chan struct{}
	resume  chan struct{}
}

func (b *blockedBody) Read(p []byte) (int, error) {
	if b.entered != nil {
		close(b.entered)
		b.entered = nil
		<-b.resume
	}
	return b.Reader.Read(p)
}

func TestCreateFirstUserAtomic(t *testing.T) {
	for _, scenario := range []string{"parked body", "concurrent requests", "rollback"} {
		t.Run(scenario, func(t *testing.T) {
			h, err := beszelTests.NewTestHub(t.TempDir())
			require.NoError(t, err)
			defer h.Cleanup()
			h.StartHub()
			um := users.NewUserManager(h.App)
			invoke := func(body io.Reader) int {
				req := httptest.NewRequest("POST", "/api/beszel/create-user", body)
				req.Header.Set("Content-Type", "application/json")
				res := httptest.NewRecorder()
				if err := um.CreateFirstUser(&core.RequestEvent{App: h.App, Event: router.Event{Request: req, Response: res}}); err != nil {
					t.Error(err)
				}
				return res.Code
			}
			body := func(email string) io.Reader {
				return strings.NewReader(`{"email":"` + email + `","password":"password12345"}`)
			}
			await := func(results <-chan int) int {
				select {
				case status := <-results:
					return status
				case <-time.After(10 * time.Second):
					t.Fatal("request did not finish")
					return 0
				}
			}
			switch scenario {
			case "parked body":
				entered, resume := make(chan struct{}), make(chan struct{})
				defer func() {
					select {
					case <-resume:
					default:
						close(resume)
					}
				}()
				result := make(chan int, 1)
				go func() { result <- invoke(&blockedBody{body("[email protected]"), entered, resume}) }()
				select {
				case <-entered:
				case <-time.After(10 * time.Second):
					t.Fatal("request did not reach body parsing")
				}
				require.Equal(t, 200, invoke(body("[email protected]")))
				close(resume)
				require.Equal(t, 403, await(result))
			case "concurrent requests":
				start := make(chan struct{})
				results := make(chan int, 2)
				for _, email := range []string{"[email protected]", "[email protected]"} {
					go func() { <-start; results <- invoke(body(email)) }()
				}
				close(start)
				require.ElementsMatch(t, []int{200, 403}, []int{await(results), await(results)})
			case "rollback":
				hook := h.OnRecordCreate(core.CollectionNameSuperusers).BindFunc(func(e *core.RecordEvent) error {
					return errors.New("injected superuser creation failure")
				})
				require.Equal(t, 500, invoke(body("[email protected]")))
				count, err := h.CountRecords("users")
				require.NoError(t, err)
				require.Zero(t, count)
				admins, err := h.FindAllRecords(core.CollectionNameSuperusers)
				require.NoError(t, err)
				require.Len(t, admins, 1)
				require.Equal(t, migrations.TempAdminEmail, admins[0].Email())
				h.OnRecordCreate(core.CollectionNameSuperusers).Unbind(hook)
				require.Equal(t, 200, invoke(body("[email protected]")))
			}
			count, err := h.CountRecords("users")
			require.NoError(t, err)
			require.EqualValues(t, 1, count)
			bootstrapUsers, err := h.FindAllRecords("users")
			require.NoError(t, err)
			require.Equal(t, "admin", bootstrapUsers[0].GetString("role"))
			admins, err := h.FindAllRecords(core.CollectionNameSuperusers)
			require.NoError(t, err)
			require.Len(t, admins, 1)
			require.NotEqual(t, migrations.TempAdminEmail, admins[0].Email())
		})
	}
}