server_test.go

package main

import (
	"bytes"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"

	"github.com/girish/storage/store"
)

func TestHTTPPutStoresFile(t *testing.T) {
	root := t.TempDir()
	localStore := store.NewStore(store.StoreOpts{
		Root:              root,
		PathTransformFunc: store.CASPathTransfromFunc,
	})
	server := NewFileServer(FileServerOpts{Store: localStore})

	const key = "curl-upload-test"
	expected := []byte("uploaded over HTTP")
	req := httptest.NewRequest(http.MethodPut, "/files/"+key, bytes.NewReader(expected))
	response := httptest.NewRecorder()
	server.httpHandler().ServeHTTP(response, req)

	if response.Code != http.StatusCreated {
		t.Fatalf("expected status %d, got %d: %s", http.StatusCreated, response.Code, response.Body.String())
	}

	pathKey := store.CASPathTransfromFunc(key)
	filePath := filepath.Join(root, filepath.FromSlash(pathKey.FullPath()))
	actual, err := os.ReadFile(filePath)
	if err != nil {
		t.Fatalf("failed to read stored file: %v", err)
	}
	if !bytes.Equal(actual, expected) {
		t.Fatalf("stored content = %q, want %q", actual, expected)
	}
}

func TestHTTPPutReplicatesToPeerWithoutLooping(t *testing.T) {
	newNode := func(t *testing.T) *FileServer {
		t.Helper()
		localStore := store.NewStore(store.StoreOpts{
			Root:              t.TempDir(),
			PathTransformFunc: store.CASPathTransfromFunc,
		})
		return NewFileServer(FileServerOpts{Store: localStore})
	}

	first := newNode(t)
	second := newNode(t)
	firstHTTP := httptest.NewServer(first.httpHandler())
	defer firstHTTP.Close()
	secondHTTP := httptest.NewServer(second.httpHandler())
	defer secondHTTP.Close()
	first.Peers = []string{secondHTTP.URL}
	second.Peers = []string{firstHTTP.URL}

	const key = "replication-test"
	expected := []byte("replicated between nodes")
	req := httptest.NewRequest(http.MethodPut, "/files/"+key, bytes.NewReader(expected))
	response := httptest.NewRecorder()
	first.httpHandler().ServeHTTP(response, req)
	if response.Code != http.StatusCreated {
		t.Fatalf("expected status %d, got %d: %s", http.StatusCreated, response.Code, response.Body.String())
	}

	for _, node := range []*FileServer{first, second} {
		pathKey := store.CASPathTransfromFunc(key)
		filePath := filepath.Join(node.Store.Root, filepath.FromSlash(pathKey.FullPath()))
		actual, err := os.ReadFile(filePath)
		if err != nil {
			t.Fatalf("failed to read replicated file: %v", err)
		}
		if !bytes.Equal(actual, expected) {
			t.Fatalf("stored content = %q, want %q", actual, expected)
		}
	}
}