feat: implement security, discovery, history, file transfer, web UI (P0-P3)

2026-08-14 09:45:54 -04:00
parent 8281478f0c
commit 884415c1c1
32 changed files with 1923 additions and 200 deletions
@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"os"
+	"strings"
 	"testing"

 	"git.dracodev.net/Projets/clip-sync/internal/dedup"
@@ -16,29 +17,37 @@ type mockClipboard struct {
 	text string
 }

-func (m *mockClipboard) Read() (string, error)  { return m.text, nil }
-func (m *mockClipboard) Write(s string) error    { m.text = s; return nil }
+func (m *mockClipboard) Read() (string, error) { return m.text, nil }
+func (m *mockClipboard) Write(s string) error  { m.text = s; return nil }

-func TestHandleClipAcceptsValidPayload(t *testing.T) {
-	cb := &mockClipboard{}
+func newTestServer(cb *mockClipboard, opts Options) *Server {
 	filter := dedup.NewFilter("my-machine")
-	srv := New(":0", cb, filter)
+	return New(opts, cb, filter)
+}

-	payload := dedup.Payload{
-		Text:   "test text",
-		Ts:     1690000000000000000,
-		Origin: "other-machine",
-	}
+func doClip(t *testing.T, s *Server, payload dedup.Payload, headers map[string]string) *httptest.ResponseRecorder {
+	t.Helper()
 	body, err := json.Marshal(payload)
 	if err != nil {
 		t.Fatalf("json.Marshal: %v", err)
 	}
-
 	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
 	w := httptest.NewRecorder()
+	s.handleClip(w, req)
+	return w
+}

-	srv.handleClip(w, req)
+func TestHandleClipAcceptsValidPayload(t *testing.T) {
+	cb := &mockClipboard{}
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20})
+
+	w := doClip(t, srv, dedup.Payload{
+		Text: "test text", Ts: 1690000000000000000, Origin: "other-machine",
+	}, nil)

 	if w.Code != http.StatusNoContent {
 		t.Errorf("status = %d, want %d", w.Code, http.StatusNoContent)
@@ -50,32 +59,18 @@ func TestHandleClipAcceptsValidPayload(t *testing.T) {

 func TestHandleClipIgnoresEcho(t *testing.T) {
 	cb := &mockClipboard{text: "existing"}
-	filter := dedup.NewFilter("my-machine")
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20})

 	// Simulate we just wrote "echo text" locally.
-	filter.MarkWritten("echo text")
+	srv.filter.MarkWritten("echo text")

-	srv := New(":0", cb, filter)
-
-	payload := dedup.Payload{
-		Text:   "echo text", // same text we just wrote
-		Ts:     1690000000000000000,
-		Origin: "other-machine",
-	}
-	body, err := json.Marshal(payload)
-	if err != nil {
-		t.Fatalf("json.Marshal: %v", err)
-	}
-
-	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader(body))
-	w := httptest.NewRecorder()
-
-	srv.handleClip(w, req)
+	w := doClip(t, srv, dedup.Payload{
+		Text: "echo text", Ts: 1690000000000000000, Origin: "other-machine",
+	}, nil)

 	if w.Code != http.StatusNoContent {
 		t.Errorf("status = %d, want %d", w.Code, http.StatusNoContent)
 	}
-	// Clipboard should NOT be overwritten.
 	if cb.text != "existing" {
 		t.Errorf("clipboard = %q, want \"existing\" (should not be overwritten)", cb.text)
 	}
@@ -83,8 +78,7 @@ func TestHandleClipIgnoresEcho(t *testing.T) {

 func TestHandleClipRejectsInvalidMethod(t *testing.T) {
 	cb := &mockClipboard{}
-	filter := dedup.NewFilter("my-machine")
-	srv := New(":0", cb, filter)
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20})

 	req := httptest.NewRequest(http.MethodGet, "/clip", nil)
 	w := httptest.NewRecorder()
@@ -98,23 +92,11 @@ func TestHandleClipRejectsInvalidMethod(t *testing.T) {

 func TestHandleClipRejectsEmptyText(t *testing.T) {
 	cb := &mockClipboard{}
-	filter := dedup.NewFilter("my-machine")
-	srv := New(":0", cb, filter)
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20})

-	payload := dedup.Payload{
-		Text:   "",
-		Ts:     1690000000000000000,
-		Origin: "other-machine",
-	}
-	body, err := json.Marshal(payload)
-	if err != nil {
-		t.Fatalf("json.Marshal: %v", err)
-	}
-
-	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader(body))
-	w := httptest.NewRecorder()
-
-	srv.handleClip(w, req)
+	w := doClip(t, srv, dedup.Payload{
+		Text: "", Ts: 1690000000000000000, Origin: "other-machine",
+	}, nil)

 	if w.Code != http.StatusBadRequest {
 		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
@@ -123,8 +105,7 @@ func TestHandleClipRejectsEmptyText(t *testing.T) {

 func TestHandleClipRejectsInvalidJSON(t *testing.T) {
 	cb := &mockClipboard{}
-	filter := dedup.NewFilter("my-machine")
-	srv := New(":0", cb, filter)
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20})

 	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader([]byte("not json")))
 	w := httptest.NewRecorder()
@@ -136,7 +117,95 @@ func TestHandleClipRejectsInvalidJSON(t *testing.T) {
 	}
 }

+func TestHandleClipRequiresSharedKey(t *testing.T) {
+	cb := &mockClipboard{}
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20, SharedKey: "secret"})
+
+	// No auth header → unauthorized.
+	w := doClip(t, srv, dedup.Payload{Text: "x", Ts: 1, Origin: "other-machine"}, nil)
+	if w.Code != http.StatusUnauthorized {
+		t.Errorf("status = %d, want %d (missing key)", w.Code, http.StatusUnauthorized)
+	}
+
+	// Wrong key → unauthorized.
+	w = doClip(t, srv, dedup.Payload{Text: "x", Ts: 1, Origin: "other-machine"},
+		map[string]string{"Authorization": "Bearer wrong"})
+	if w.Code != http.StatusUnauthorized {
+		t.Errorf("status = %d, want %d (wrong key)", w.Code, http.StatusUnauthorized)
+	}
+
+	// Correct key → accepted.
+	w = doClip(t, srv, dedup.Payload{Text: "x", Ts: 2, Origin: "other-machine"},
+		map[string]string{"Authorization": "Bearer secret"})
+	if w.Code != http.StatusNoContent {
+		t.Errorf("status = %d, want %d (correct key)", w.Code, http.StatusNoContent)
+	}
+}
+
+func TestHandleClipRejectsUnknownOrigin(t *testing.T) {
+	cb := &mockClipboard{}
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20, AllowedOrigins: []string{"trusted-host"}})
+
+	w := doClip(t, srv, dedup.Payload{Text: "x", Ts: 1, Origin: "evil-host"}, nil)
+	if w.Code != http.StatusForbidden {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusForbidden)
+	}
+}
+
+func TestHandleClipEnforcesBodyLimit(t *testing.T) {
+	cb := &mockClipboard{}
+	srv := newTestServer(cb, Options{MaxBodyBytes: 16})
+
+	req := httptest.NewRequest(http.MethodPost, "/clip", strings.NewReader(`{"text":"`+strings.Repeat("a", 1024)+`"}`))
+	w := httptest.NewRecorder()
+
+	srv.handleClip(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("status = %d, want %d (oversized body)", w.Code, http.StatusBadRequest)
+	}
+}
+
+func TestHandleFileReception(t *testing.T) {
+	cb := &mockClipboard{}
+	dir := t.TempDir()
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20, ReceiveFiles: true, ReceiveDir: dir})
+
+	body := `{"name":"hello.txt","mime":"text/plain","data":"aGVsbG8=","ts":1,"origin":"other-machine"}`
+	req := httptest.NewRequest(http.MethodPost, "/file", strings.NewReader(body))
+	w := httptest.NewRecorder()
+
+	srv.handleFile(w, req)
+
+	if w.Code != http.StatusNoContent {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusNoContent)
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil || len(entries) == 0 {
+		t.Fatalf("expected a file in %s, got %d entries (err=%v)", dir, len(entries), err)
+	}
+	data, _ := os.ReadFile(dir + "/" + entries[0].Name())
+	if string(data) != "hello" {
+		t.Errorf("file content = %q, want \"hello\"", data)
+	}
+}
+
+func TestHandleFileDisabled(t *testing.T) {
+	cb := &mockClipboard{}
+	srv := newTestServer(cb, Options{MaxBodyBytes: 1 << 20}) // ReceiveFiles defaults false
+
+	body := `{"name":"x","data":"eA==","ts":1,"origin":"other-machine"}`
+	req := httptest.NewRequest(http.MethodPost, "/file", strings.NewReader(body))
+	w := httptest.NewRecorder()
+
+	srv.handleFile(w, req)
+
+	if w.Code != http.StatusForbidden {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusForbidden)
+	}
+}
+
 func TestMain(m *testing.M) {
-	// Ensure clipboard.New() won't be called in test (mock is used directly).
 	os.Exit(m.Run())
 }