feat: implémentation complete v0.1.0 — daemon de sync clipboard bidirectionnel

internal/server/server.go

@@ -0,0 +1,79 @@
+// Package server provides the HTTP endpoint that receives clipboard payloads
+// from remote clip-sync peers.
+package server
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"git.dracodev.net/Projets/clip-sync/internal/clipboard"
+	"git.dracodev.net/Projets/clip-sync/internal/dedup"
+)
+
+// Server receives clips from peers and writes them to the local clipboard.
+type Server struct {
+	httpServer *http.Server
+	clipboard  clipboard.Clipboard
+	filter     *dedup.Filter
+}
+
+// New creates a Server that listens on addr.
+func New(addr string, cb clipboard.Clipboard, filter *dedup.Filter) *Server {
+	s := &Server{
+		clipboard: cb,
+		filter:    filter,
+	}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/clip", s.handleClip)
+
+	s.httpServer = &http.Server{
+		Addr:    addr,
+		Handler: mux,
+	}
+
+	return s
+}
+
+// ListenAndServe starts the HTTP server. It blocks until the server is stopped.
+func (s *Server) ListenAndServe() error {
+	return s.httpServer.ListenAndServe()
+}
+
+// Close gracefully shuts down the HTTP server.
+func (s *Server) Close() error {
+	return s.httpServer.Close()
+}
+
+func (s *Server) handleClip(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var p dedup.Payload
+	if err := json.NewDecoder(r.Body).Decode(&p); err != nil {
+		http.Error(w, "bad request: invalid JSON", http.StatusBadRequest)
+		return
+	}
+
+	if p.Text == "" {
+		http.Error(w, "bad request: empty text", http.StatusBadRequest)
+		return
+	}
+
+	if s.filter.ShouldIgnore(p) {
+		w.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	if err := s.clipboard.Write(p.Text); err != nil {
+		log.Printf("server: clipboard write: %v", err)
+		http.Error(w, "internal server error", http.StatusInternalServerError)
+		return
+	}
+
+	s.filter.MarkWritten(p.Text)
+	w.WriteHeader(http.StatusNoContent)
+}

internal/server/server_test.go

@@ -0,0 +1,133 @@
+package server
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"git.dracodev.net/Projets/clip-sync/internal/dedup"
+)
+
+// mockClipboard is an in-memory clipboard for testing.
+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 TestHandleClipAcceptsValidPayload(t *testing.T) {
+	cb := &mockClipboard{}
+	filter := dedup.NewFilter("my-machine")
+	srv := New(":0", cb, filter)
+
+	payload := dedup.Payload{
+		Text:   "test text",
+		Ts:     1690000000000000000,
+		Origin: "other-machine",
+	}
+	body, _ := json.Marshal(payload)
+
+	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+
+	srv.handleClip(w, req)
+
+	if w.Code != http.StatusNoContent {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusNoContent)
+	}
+	if cb.text != "test text" {
+		t.Errorf("clipboard = %q, want \"test text\"", cb.text)
+	}
+}
+
+func TestHandleClipIgnoresEcho(t *testing.T) {
+	cb := &mockClipboard{text: "existing"}
+	filter := dedup.NewFilter("my-machine")
+
+	// Simulate we just wrote "echo text" locally.
+	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, _ := json.Marshal(payload)
+
+	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader(body))
+	w := httptest.NewRecorder()
+
+	srv.handleClip(w, req)
+
+	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)
+	}
+}
+
+func TestHandleClipRejectsInvalidMethod(t *testing.T) {
+	cb := &mockClipboard{}
+	filter := dedup.NewFilter("my-machine")
+	srv := New(":0", cb, filter)
+
+	req := httptest.NewRequest(http.MethodGet, "/clip", nil)
+	w := httptest.NewRecorder()
+
+	srv.handleClip(w, req)
+
+	if w.Code != http.StatusMethodNotAllowed {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusMethodNotAllowed)
+	}
+}
+
+func TestHandleClipRejectsEmptyText(t *testing.T) {
+	cb := &mockClipboard{}
+	filter := dedup.NewFilter("my-machine")
+	srv := New(":0", cb, filter)
+
+	payload := dedup.Payload{
+		Text:   "",
+		Ts:     1690000000000000000,
+		Origin: "other-machine",
+	}
+	body, _ := json.Marshal(payload)
+
+	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader(body))
+	w := httptest.NewRecorder()
+
+	srv.handleClip(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
+	}
+}
+
+func TestHandleClipRejectsInvalidJSON(t *testing.T) {
+	cb := &mockClipboard{}
+	filter := dedup.NewFilter("my-machine")
+	srv := New(":0", cb, filter)
+
+	req := httptest.NewRequest(http.MethodPost, "/clip", bytes.NewReader([]byte("not json")))
+	w := httptest.NewRecorder()
+
+	srv.handleClip(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
+	}
+}
+
+func TestMain(m *testing.M) {
+	// Ensure clipboard.New() won't be called in test (mock is used directly).
+	os.Exit(m.Run())
+}