Add mock-backed integration testing tier and fake Dynu API

2026-04-21 15:19:20 +10:00
parent 7f161fb19b
commit 293fe7af28
10 changed files with 564 additions and 154 deletions
@@ -0,0 +1,204 @@
+package fakedynu
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/dynu/terraform-provider-dynu/internal/dynuclient"
+)
+
+type RootDomain struct {
+	ID         int64
+	Hostname   string
+	DomainName string
+	Node       string
+}
+
+type APIError struct {
+	HTTPStatus int
+	StatusCode int
+	Type       string
+	Message    string
+}
+
+type Fixture struct {
+	Domains         []dynuclient.Domain
+	RootsByHostname map[string]RootDomain
+	RecordsByDomain map[int64][]dynuclient.DNSRecord
+}
+
+type Server struct {
+	*httptest.Server
+
+	mu         sync.RWMutex
+	fixture    Fixture
+	errors     map[string]APIError
+	rawPayload map[string]rawResponse
+}
+
+type rawResponse struct {
+	httpStatus int
+	body       string
+}
+
+func NewServer() *Server {
+	s := &Server{
+		errors:     map[string]APIError{},
+		rawPayload: map[string]rawResponse{},
+		fixture: Fixture{
+			Domains: []dynuclient.Domain{
+				{ID: 2002, Name: "z.example.com", UnicodeName: "z.example.com", TTL: 60, CreatedOn: "2024-01-03T00:00:00", UpdatedOn: "2024-01-04T00:00:00"},
+				{ID: 1001, Name: "a.example.com", UnicodeName: "a.example.com", TTL: 120, CreatedOn: "2024-01-01T00:00:00", UpdatedOn: "2024-01-02T00:00:00"},
+			},
+			RootsByHostname: map[string]RootDomain{
+				"www.a.example.com": {ID: 1001, Hostname: "www.a.example.com", DomainName: "a.example.com", Node: "www"},
+				"api.a.example.com": {ID: 1001, Hostname: "api.a.example.com", DomainName: "a.example.com", Node: "api"},
+			},
+			RecordsByDomain: map[int64][]dynuclient.DNSRecord{
+				1001: {
+					{ID: 20, DomainID: 1001, DomainName: "a.example.com", NodeName: "www", Hostname: "www.a.example.com", RecordType: "TXT", TTL: 90, State: true, Content: "v=spf1", UpdatedOn: "2024-01-03T11:00:00"},
+					{ID: 10, DomainID: 1001, DomainName: "a.example.com", NodeName: "www", Hostname: "www.a.example.com", RecordType: "A", TTL: 30, State: true, Content: "203.0.113.5", UpdatedOn: "2024-01-03T10:00:00"},
+				},
+			},
+		},
+	}
+
+	s.Server = httptest.NewServer(http.HandlerFunc(s.serveHTTP))
+	return s
+}
+
+func (s *Server) BaseURL() string {
+	return s.URL
+}
+
+func (s *Server) SetFixture(fixture Fixture) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.fixture = fixture
+}
+
+func (s *Server) SetAPIError(path string, apiErr APIError) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.errors[path] = apiErr
+}
+
+func (s *Server) SetRawResponse(path string, httpStatus int, body string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.rawPayload[path] = rawResponse{httpStatus: httpStatus, body: body}
+}
+
+func (s *Server) serveHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		w.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	if raw, ok := s.rawPayload[r.URL.Path]; ok {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(raw.httpStatus)
+		_, _ = w.Write([]byte(raw.body))
+		return
+	}
+
+	if apiErr, ok := s.errors[r.URL.Path]; ok {
+		s.writeAPIError(w, apiErr)
+		return
+	}
+
+	switch {
+	case r.URL.Path == "/dns":
+		s.writeJSON(w, http.StatusOK, map[string]any{"statusCode": 200, "domains": s.fixture.Domains})
+		return
+	case strings.HasPrefix(r.URL.Path, "/dns/getroot/"):
+		hostname := strings.TrimPrefix(r.URL.Path, "/dns/getroot/")
+		root, ok := s.fixture.RootsByHostname[hostname]
+		if !ok {
+			s.writeAPIError(w, APIError{HTTPStatus: http.StatusNotFound, StatusCode: 404, Type: "Not Found", Message: "hostname not found"})
+			return
+		}
+		s.writeJSON(w, http.StatusOK, map[string]any{
+			"statusCode": 200,
+			"id":         root.ID,
+			"hostname":   root.Hostname,
+			"domainName": root.DomainName,
+			"node":       root.Node,
+		})
+		return
+	case strings.HasSuffix(r.URL.Path, "/record"):
+		domainID, err := domainIDFromPath(strings.TrimSuffix(r.URL.Path, "/record"))
+		if err != nil {
+			s.writeAPIError(w, APIError{HTTPStatus: http.StatusBadRequest, StatusCode: 400, Type: "Validation Exception", Message: err.Error()})
+			return
+		}
+		records, ok := s.fixture.RecordsByDomain[domainID]
+		if !ok {
+			records = []dynuclient.DNSRecord{}
+		}
+		s.writeJSON(w, http.StatusOK, map[string]any{"statusCode": 200, "dnsRecords": records})
+		return
+	default:
+		domainID, err := domainIDFromPath(r.URL.Path)
+		if err != nil {
+			s.writeAPIError(w, APIError{HTTPStatus: http.StatusNotFound, StatusCode: 404, Type: "Not Found", Message: "endpoint not found"})
+			return
+		}
+		for _, domain := range s.fixture.Domains {
+			if domain.ID == domainID {
+				payload := map[string]any{"statusCode": 200}
+				b, _ := json.Marshal(domain)
+				_ = json.Unmarshal(b, &payload)
+				s.writeJSON(w, http.StatusOK, payload)
+				return
+			}
+		}
+		s.writeAPIError(w, APIError{HTTPStatus: http.StatusNotFound, StatusCode: 404, Type: "Not Found", Message: "domain not found"})
+	}
+}
+
+func domainIDFromPath(path string) (int64, error) {
+	trimmed := strings.TrimPrefix(path, "/dns/")
+	if trimmed == path {
+		return 0, fmt.Errorf("invalid domain path: %s", path)
+	}
+
+	id, err := strconv.ParseInt(trimmed, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("invalid domain id: %s", trimmed)
+	}
+	return id, nil
+}
+
+func (s *Server) writeAPIError(w http.ResponseWriter, apiErr APIError) {
+	if apiErr.HTTPStatus == 0 {
+		apiErr.HTTPStatus = http.StatusBadRequest
+	}
+	if apiErr.StatusCode == 0 {
+		apiErr.StatusCode = apiErr.HTTPStatus
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(apiErr.HTTPStatus)
+	_ = json.NewEncoder(w).Encode(map[string]any{
+		"statusCode": apiErr.StatusCode,
+		"exception": map[string]any{
+			"statusCode": apiErr.StatusCode,
+			"type":       apiErr.Type,
+			"message":    apiErr.Message,
+		},
+	})
+}
+
+func (s *Server) writeJSON(w http.ResponseWriter, status int, payload any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(payload)
+}