provider_test.go

package httpnet_test

import (
	"context"
	"os"
	"sort"
	"testing"
	"time"

	"github.com/libdns/httpnet"
	"github.com/libdns/libdns"
)

// Integration tests that run against the live http.net API.
// Set the following environment variables to run these tests:
//
//	HTTPNET_AUTH_TOKEN  – your http.net API token
//	HTTPNET_TEST_ZONE   – a zone you control (e.g. "example.com.")
func newProvider(t *testing.T) (*httpnet.Provider, string) {
	t.Helper()
	token := os.Getenv("HTTPNET_AUTH_TOKEN")
	zone := os.Getenv("HTTPNET_TEST_ZONE")
	if token == "" || zone == "" {
		t.Skip("HTTPNET_AUTH_TOKEN and HTTPNET_TEST_ZONE must be set to run integration tests")
	}
	return &httpnet.Provider{AuthToken: token}, zone
}

// deleteByName fetches the zone and deletes all records matching the given
// relative name. Used for cleanup so that content changes don't break matching.
func deleteByName(t *testing.T, p *httpnet.Provider, zone, name string) {
	t.Helper()
	ctx := context.Background()
	all, err := p.GetRecords(ctx, zone)
	if err != nil {
		t.Logf("cleanup GetRecords: %v", err)
		return
	}
	var toDelete []libdns.Record
	for _, r := range all {
		if r.RR().Name == name {
			toDelete = append(toDelete, r)
		}
	}
	if len(toDelete) == 0 {
		return
	}
	if _, err := p.DeleteRecords(ctx, zone, toDelete); err != nil {
		t.Logf("cleanup DeleteRecords: %v", err)
	}
}

func TestGetRecords(t *testing.T) {
	p, zone := newProvider(t)
	records, err := p.GetRecords(context.Background(), zone)
	if err != nil {
		t.Fatalf("GetRecords: %v", err)
	}
	t.Logf("found %d records in zone %s", len(records), zone)
}

func TestAppendAndDeleteRecords(t *testing.T) {
	p, zone := newProvider(t)
	ctx := context.Background()

	// Remove any leftovers from a previously interrupted run.
	deleteByName(t, p, zone, "_libdns_test")
	t.Cleanup(func() { deleteByName(t, p, zone, "_libdns_test") })

	toCreate := []libdns.Record{
		libdns.TXT{
			Name: "_libdns_test",
			TTL:  60 * time.Second,
			Text: "libdns-httpnet-test-value",
		},
	}

	created, err := p.AppendRecords(ctx, zone, toCreate)
	if err != nil {
		t.Fatalf("AppendRecords: %v", err)
	}
	t.Logf("created: %+v", created)

	deleted, err := p.DeleteRecords(ctx, zone, created)
	if err != nil {
		t.Fatalf("DeleteRecords: %v", err)
	}
	t.Logf("deleted: %+v", deleted)
}

func TestSetRecords(t *testing.T) {
	p, zone := newProvider(t)
	ctx := context.Background()

	// Remove any leftovers from a previously interrupted run.
	deleteByName(t, p, zone, "_libdns_set_test")
	t.Cleanup(func() { deleteByName(t, p, zone, "_libdns_set_test") })

	initial := libdns.TXT{
		Name: "_libdns_set_test",
		TTL:  60 * time.Second,
		Text: "initial",
	}

	created, err := p.AppendRecords(ctx, zone, []libdns.Record{initial})
	if err != nil {
		t.Fatalf("AppendRecords: %v", err)
	}

	updated := libdns.TXT{
		Name: "_libdns_set_test",
		TTL:  60 * time.Second,
		Text: "updated",
	}
	set, err := p.SetRecords(ctx, zone, []libdns.Record{updated})
	if err != nil {
		_, _ = p.DeleteRecords(ctx, zone, created)
		t.Fatalf("SetRecords: %v", err)
	}
	t.Logf("set: %+v", set)
}

// TestMultipleTXTSameName verifies that http.net accepts multiple TXT records
// at the same (name, type) -- which is what ACME DNS-01 requires for a
// wildcard + apex certificate (two TXT records at _acme-challenge.<zone>).
func TestMultipleTXTSameName(t *testing.T) {
	p, zone := newProvider(t)
	ctx := context.Background()

	const name = "_libdns_multitxt_test"
	deleteByName(t, p, zone, name)
	t.Cleanup(func() { deleteByName(t, p, zone, name) })

	if _, err := p.AppendRecords(ctx, zone, []libdns.Record{
		libdns.TXT{Name: name, TTL: 60 * time.Second, Text: "value-one"},
		libdns.TXT{Name: name, TTL: 60 * time.Second, Text: "value-two"},
	}); err != nil {
		t.Fatalf("AppendRecords: %v", err)
	}

	all, err := p.GetRecords(ctx, zone)
	if err != nil {
		t.Fatalf("GetRecords: %v", err)
	}
	var values []string
	for _, r := range all {
		rr := r.RR()
		if rr.Name == name && rr.Type == "TXT" {
			values = append(values, rr.Data)
		}
	}
	sort.Strings(values)

	want := []string{"value-one", "value-two"}
	if len(values) != len(want) || values[0] != want[0] || values[1] != want[1] {
		t.Errorf("got %v, want %v", values, want)
	}
}