OpenFlare/internal/apps/openflare/cloudflare/wildcard_test.go

// Copyright 2026 Arctel.net
// SPDX-License-Identifier: Apache-2.0

package cloudflare

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"sync/atomic"
	"testing"

	"github.com/Rain-kl/Wavelet/internal/model"
	"github.com/Rain-kl/Wavelet/internal/repository"
)

func TestWildcardMemberDNSRecords(t *testing.T) {
	tests := []struct {
		name, mode, recordType, content string
		proxied                         bool
	}{
		{name: "custom_A", mode: model.CFPointingTargetModeCustom, recordType: "A", content: "203.0.113.20"},
		{name: "custom_AAAA", mode: model.CFPointingTargetModeCustom, recordType: "AAAA", content: "2001:db8::20", proxied: true},
		{name: "custom_CNAME", mode: model.CFPointingTargetModeCustom, recordType: "CNAME", content: "edge.example.net", proxied: true},
		{name: "node_A", recordType: "A", content: "203.0.113.10", proxied: true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ctx, originalID := setupCloudflareLogicDB(t)
			state, err := repository.GetCFPointingMemberContext(ctx, originalID)
			if err != nil {
				t.Fatal(err)
			}
			state.Group.TargetMode, state.Group.RecordType, state.Group.RecordContent = tt.mode, tt.recordType, tt.content
			state.Group.DefaultProxied = tt.proxied
			if err := repository.SaveCFPointingGroup(ctx, &state.Group); err != nil {
				t.Fatal(err)
			}
			if tt.mode != model.CFPointingTargetModeCustom {
				if err := repository.UpdateOpenFlareNodeColumns(ctx, &state.Node, map[string]any{"ip": tt.content}); err != nil {
					t.Fatal(err)
				}
			}
			domain := &model.ZoneDomain{ZoneID: state.Zone.ID, Domain: "*.s3.example.com"}
			if err := repository.CreateZoneDomain(ctx, domain); err != nil {
				t.Fatal(err)
			}
			available, err := ListAvailableDomains(ctx)
			if err != nil || len(available) != 1 || available[0].Domain != domain.Domain {
				t.Fatalf("ListAvailableDomains() = %+v, %v, want wildcard domain", available, err)
			}
			t.Cleanup(SetDispatchTaskForTest(func(context.Context, string, []byte, string) (string, error) { return "task-1", nil }))
			member, err := CreateMember(ctx, state.Group.ID, MemberCreateInput{ZoneDomainID: domain.ID})
			if err != nil {
				t.Fatalf("CreateMember(wildcard) error = %v", err)
			}
			var creates, updates, deletes atomic.Int32
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				switch r.URL.Path {
				case "/zones":
					if got := r.URL.Query().Get("name"); got != "example.com" {
						t.Errorf("FindZone name = %q, want example.com", got)
					}
					writeCFTestResponse(t, w, []Zone{{ID: "zone-1", Name: "example.com"}})
				case "/zones/zone-1/dns_records", "/zones/zone-1/dns_records/wildcard-record":
					if (r.Method == http.MethodPut || r.Method == http.MethodDelete) && r.URL.Path != "/zones/zone-1/dns_records/wildcard-record" {
						t.Errorf("DNS %s path = %q, want record ID path", r.Method, r.URL.Path)
						w.WriteHeader(http.StatusMethodNotAllowed)
						return
					}
					switch r.Method {
					case http.MethodGet:
						if r.URL.Path == "/zones/zone-1/dns_records/wildcard-record" {
							writeCFTestResponse(t, w, DNSRecord{ID: "wildcard-record", Name: domain.Domain, Type: tt.recordType})
							return
						}
						if r.URL.Query().Get("name") != domain.Domain || r.URL.Query().Get("type") != tt.recordType {
							t.Errorf("ListRecords query = %v, want wildcard name and %s", r.URL.Query(), tt.recordType)
						}
						writeCFTestResponse(t, w, []DNSRecord{})
					case http.MethodPost, http.MethodPut:
						var input RecordInput
						if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
							t.Errorf("Decode(record) error = %v", err)
							w.WriteHeader(http.StatusBadRequest)
							return
						}
						wantTTL := 300
						if tt.proxied {
							wantTTL = 1
						}
						if input.Name != domain.Domain || input.Type != tt.recordType || input.Content != tt.content || input.Proxied != tt.proxied || input.TTL != wantTTL {
							t.Errorf("DNS record input = %+v, want name=%s type=%s content=%s proxied=%t TTL=%d", input, domain.Domain, tt.recordType, tt.content, tt.proxied, wantTTL)
						}
						if r.Method == http.MethodPost {
							creates.Add(1)
						} else {
							updates.Add(1)
						}
						writeCFTestResponse(t, w, DNSRecord{ID: "wildcard-record", Name: input.Name, Type: input.Type, Content: input.Content})
					case http.MethodDelete:
						deletes.Add(1)
						writeCFTestResponse(t, w, map[string]string{"id": "wildcard-record"})
					default:
						t.Errorf("unexpected method %s", r.Method)
						w.WriteHeader(http.StatusMethodNotAllowed)
					}
				default:
					t.Errorf("unexpected Cloudflare path %s", r.URL.Path)
					w.WriteHeader(http.StatusNotFound)
				}
			}))
			t.Cleanup(server.Close)
			t.Cleanup(SetClientFactoryForTest(func(token string) Client {
				return NewHTTPClient(token, WithBaseURL(server.URL), WithHTTPClient(server.Client()))
			}))
			for range 2 {
				if err := ReconcileMember(ctx, member.ID); err != nil {
					t.Fatalf("ReconcileMember(wildcard %s) error = %v", tt.recordType, err)
				}
			}
			stored, err := repository.GetCFPointingMemberByID(ctx, member.ID)
			if err != nil || stored.SyncStatus != model.CFMemberSyncOK || stored.CFRecordID != "wildcard-record" {
				t.Fatalf("synced wildcard member = %+v, error=%v", stored, err)
			}
			if err := DeleteManagedRecord(ctx, member.ID); err != nil {
				t.Fatalf("DeleteManagedRecord(wildcard) error = %v", err)
			}
			if creates.Load() != 1 || updates.Load() != 1 || deletes.Load() != 1 {
				t.Errorf("DNS create/update/delete counts = %d/%d/%d, want 1/1/1", creates.Load(), updates.Load(), deletes.Load())
			}
		})
	}
}