You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/gateway/update/server_test.go

83 lines
3.1 KiB
Go

package update
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"strings"
"testing"
"time"
"git.luoli.live/root/virt/gateway/internal/protocol"
)
func TestSettingsNeverEchoAccessTokenAndRejectReplay(t *testing.T) {
executor := &fakeExecutor{}
manager, state := newTestManager(t, executor)
secret := []byte(strings.Repeat("x", 32))
server, err := NewServer(manager, state, secret)
if err != nil {
t.Fatal(err)
}
token := "glpat-this-must-never-appear-in-response"
body := []byte(`{"access_token":"` + token + `"}`)
request := signedAPIRequest(t, http.MethodPut, "/v1/settings", body, secret, "0123456789abcdef0123456789abcdef")
response := httptest.NewRecorder()
server.ServeHTTP(response, request)
if response.Code != http.StatusOK || strings.Contains(response.Body.String(), token) {
t.Fatalf("settings response status=%d body=%q", response.Code, response.Body.String())
}
var payload map[string]any
if err := json.Unmarshal(response.Body.Bytes(), &payload); err != nil || payload["token_configured"] != true || payload["repository"] != RequiredRemoteURL {
t.Fatalf("settings payload=%#v err=%v", payload, err)
}
replay := httptest.NewRecorder()
server.ServeHTTP(replay, request)
if replay.Code != http.StatusUnauthorized {
t.Fatalf("replay status=%d", replay.Code)
}
raw, err := os.ReadFile(state.path)
if err != nil || !bytes.Contains(raw, []byte(token)) {
t.Fatal("token was not durably stored")
}
}
func TestSettingsBlankPreservesAndClearTokenRemovesCredential(t *testing.T) {
executor := &fakeExecutor{}
manager, state := newTestManager(t, executor)
secret := []byte(strings.Repeat("x", 32))
server, _ := NewServer(manager, state, secret)
if err := state.SetAccessToken("existing-private-token"); err != nil {
t.Fatal(err)
}
preserveBody := []byte(`{"access_token":""}`)
preserve := httptest.NewRecorder()
server.ServeHTTP(preserve, signedAPIRequest(t, http.MethodPut, "/v1/settings", preserveBody, secret,
"11111111111111111111111111111111"))
if preserve.Code != http.StatusOK || state.AccessToken() != "existing-private-token" ||
strings.Contains(preserve.Body.String(), "existing-private-token") {
t.Fatalf("blank preserve status=%d token=%q body=%q", preserve.Code, state.AccessToken(), preserve.Body.String())
}
clearBody := []byte(`{"clear_token":true}`)
clear := httptest.NewRecorder()
server.ServeHTTP(clear, signedAPIRequest(t, http.MethodPut, "/v1/settings", clearBody, secret,
"22222222222222222222222222222222"))
if clear.Code != http.StatusOK || state.TokenConfigured() || strings.Contains(clear.Body.String(), "existing-private-token") {
t.Fatalf("clear status=%d configured=%v body=%q", clear.Code, state.TokenConfigured(), clear.Body.String())
}
}
func signedAPIRequest(t *testing.T, method, path string, body, secret []byte, nonce string) *http.Request {
t.Helper()
request := httptest.NewRequest(method, "http://unix"+path, bytes.NewReader(body))
actor := protocol.Actor{UserID: 1, IsAdmin: true, IsSuperAdmin: true, CanManage: true}
if err := protocol.Sign(request, body, actor, secret, time.Now(), nonce); err != nil {
t.Fatal(err)
}
return request
}