wild-cloud/wild-central
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

feat: Add tests for config, secrets, services, and cloudflare endpoints

Browse Source 
Fix config endpoint to return wrapped { configured, config } response
that the web UI expects. Fix services handler to return stored version
with defaults applied.

New tests:
- GetGlobalConfig: wrapped response, empty/not-configured case
- GetGlobalSecrets: leaf redaction preserves structure, raw mode
- UpdateGlobalConfig: write and verify
- CloudflareVerify: no-token case
- Services: register, list, get, update, deregister, TCP passthrough
  defaults, validation errors

15 new test cases, all passing.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Paul Payne
2026-07-09 04:45:55 +00:00
parent d9c152f044
commit 909527f060
4 changed files with 489 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
internal/api/v1/handlers_services_test.go Normal file
View File

@@ -0,0 +1,278 @@
package v1
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"github.com/gorilla/mux"
)
func TestServicesRegister(t *testing.T) {
api, _ := setupTestAPI(t)
body, _ := json.Marshal(map[string]any{
"name": "my-api",
"source": "wild-works",
"domain": "my-api.payne.io",
"backend": map[string]any{
"address": "192.168.8.60:9001",
"type": "http",
"health": "/health",
},
"reach": "internal",
})
req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
w := httptest.NewRecorder()
api.ServicesRegister(w, req)
if w.Code != http.StatusCreated {
t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
}
var resp map[string]any
json.Unmarshal(w.Body.Bytes(), &resp)
svc, ok := resp["service"].(map[string]any)
if !ok {
t.Fatal("expected service in response")
}
if svc["name"] != "my-api" {
t.Errorf("expected name my-api, got %v", svc["name"])
}
if svc["tls"] != "terminate" {
t.Errorf("expected tls=terminate default for http backend, got %v", svc["tls"])
}
}
func TestServicesListAll_Empty(t *testing.T) {
api, _ := setupTestAPI(t)
req := httptest.NewRequest("GET", "/api/v1/services", nil)
w := httptest.NewRecorder()
api.ServicesListAll(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
var resp map[string]any
json.Unmarshal(w.Body.Bytes(), &resp)
svcs, ok := resp["services"].([]any)
if !ok {
t.Fatal("expected services array")
}
if len(svcs) != 0 {
t.Errorf("expected empty services, got %d", len(svcs))
}
}
func TestServicesListAll_WithServices(t *testing.T) {
api, _ := setupTestAPI(t)
// Register two services
for _, name := range []string{"svc-a", "svc-b"} {
body, _ := json.Marshal(map[string]any{
"name": name,
"source": "test",
"domain": name + ".example.com",
"backend": map[string]any{"address": "127.0.0.1:8080", "type": "http"},
"reach": "internal",
})
req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
w := httptest.NewRecorder()
api.ServicesRegister(w, req)
if w.Code != http.StatusCreated {
t.Fatalf("register %s failed: %d", name, w.Code)
}
}
req := httptest.NewRequest("GET", "/api/v1/services", nil)
w := httptest.NewRecorder()
api.ServicesListAll(w, req)
var resp map[string]any
json.Unmarshal(w.Body.Bytes(), &resp)
svcs := resp["services"].([]any)
if len(svcs) != 2 {
t.Errorf("expected 2 services, got %d", len(svcs))
}
}
func TestServicesGet(t *testing.T) {
api, _ := setupTestAPI(t)
// Register
body, _ := json.Marshal(map[string]any{
"name": "get-test",
"source": "test",
"domain": "get-test.example.com",
"backend": map[string]any{"address": "127.0.0.1:9000", "type": "http"},
"reach": "internal",
})
req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
w := httptest.NewRecorder()
api.ServicesRegister(w, req)
// Get
req = httptest.NewRequest("GET", "/api/v1/services/get-test", nil)
req = mux.SetURLVars(req, map[string]string{"name": "get-test"})
w = httptest.NewRecorder()
api.ServicesGet(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
}
var svc map[string]any
json.Unmarshal(w.Body.Bytes(), &svc)
if svc["domain"] != "get-test.example.com" {
t.Errorf("expected domain get-test.example.com, got %v", svc["domain"])
}
}
func TestServicesGet_NotFound(t *testing.T) {
api, _ := setupTestAPI(t)
req := httptest.NewRequest("GET", "/api/v1/services/nonexistent", nil)
req = mux.SetURLVars(req, map[string]string{"name": "nonexistent"})
w := httptest.NewRecorder()
api.ServicesGet(w, req)
if w.Code != http.StatusNotFound {
t.Errorf("expected 404, got %d", w.Code)
}
}
func TestServicesUpdate(t *testing.T) {
api, _ := setupTestAPI(t)
// Register
body, _ := json.Marshal(map[string]any{
"name": "update-test",
"source": "test",
"domain": "update-test.example.com",
"backend": map[string]any{"address": "127.0.0.1:9000", "type": "http"},
"reach": "internal",
})
req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
w := httptest.NewRecorder()
api.ServicesRegister(w, req)
// Update reach to public
update, _ := json.Marshal(map[string]any{"reach": "public"})
req = httptest.NewRequest("PATCH", "/api/v1/services/update-test", bytes.NewReader(update))
req = mux.SetURLVars(req, map[string]string{"name": "update-test"})
w = httptest.NewRecorder()
api.ServicesUpdate(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
}
var resp map[string]any
json.Unmarshal(w.Body.Bytes(), &resp)
svc := resp["service"].(map[string]any)
if svc["reach"] != "public" {
t.Errorf("expected reach=public after update, got %v", svc["reach"])
}
}
func TestServicesDeregister(t *testing.T) {
api, _ := setupTestAPI(t)
// Register
body, _ := json.Marshal(map[string]any{
"name": "delete-me",
"source": "test",
"domain": "delete-me.example.com",
"backend": map[string]any{"address": "127.0.0.1:9000", "type": "http"},
"reach": "internal",
})
req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
w := httptest.NewRecorder()
api.ServicesRegister(w, req)
// Delete
req = httptest.NewRequest("DELETE", "/api/v1/services/delete-me", nil)
req = mux.SetURLVars(req, map[string]string{"name": "delete-me"})
w = httptest.NewRecorder()
api.ServicesDeregister(w, req)
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
// Verify it's gone
req = httptest.NewRequest("GET", "/api/v1/services/delete-me", nil)
req = mux.SetURLVars(req, map[string]string{"name": "delete-me"})
w = httptest.NewRecorder()
api.ServicesGet(w, req)
if w.Code != http.StatusNotFound {
t.Errorf("expected 404 after delete, got %d", w.Code)
}
}
func TestServicesRegister_TCPPassthrough(t *testing.T) {
api, _ := setupTestAPI(t)
body, _ := json.Marshal(map[string]any{
"name": "cloud-instance",
"source": "wild-cloud",
"domain": "cloud.payne.io",
"backend": map[string]any{
"address": "192.168.8.100:443",
"type": "tcp-passthrough",
},
"reach": "internal",
})
req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
w := httptest.NewRecorder()
api.ServicesRegister(w, req)
if w.Code != http.StatusCreated {
t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
}
var resp map[string]any
json.Unmarshal(w.Body.Bytes(), &resp)
svc := resp["service"].(map[string]any)
if svc["tls"] != "passthrough" {
t.Errorf("expected tls=passthrough for tcp-passthrough, got %v", svc["tls"])
}
}
func TestServicesRegister_Validation(t *testing.T) {
api, _ := setupTestAPI(t)
// Missing name
body, _ := json.Marshal(map[string]any{
"domain": "x.com",
"backend": map[string]any{"address": "127.0.0.1:80", "type": "http"},
})
req := httptest.NewRequest("POST", "/api/v1/services", bytes.NewReader(body))
w := httptest.NewRecorder()
api.ServicesRegister(w, req)
if w.Code != http.StatusBadRequest {
t.Errorf("expected 400 for missing name, got %d", w.Code)
}
}