478 lines
16 KiB
Go
478 lines
16 KiB
Go
package selectel
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/vasyakrg/dns-autoresolver/internal/diff"
|
|
"github.com/vasyakrg/dns-autoresolver/internal/model"
|
|
"github.com/vasyakrg/dns-autoresolver/internal/provider"
|
|
)
|
|
|
|
func creds() provider.Credentials { return provider.Credentials{Secret: "secret-token"} }
|
|
|
|
func newTestClient(h http.Handler) (*Client, *httptest.Server) {
|
|
srv := httptest.NewServer(h)
|
|
return &Client{BaseURL: srv.URL, HTTP: srv.Client()}, srv
|
|
}
|
|
|
|
func TestListZonesSendsTokenAndParses(t *testing.T) {
|
|
var gotToken string
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
gotToken = r.Header.Get("X-Auth-Token")
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "z1", "name": "example.com."},
|
|
{"id": "z2", "name": "test.org."},
|
|
},
|
|
"next_offset": 0,
|
|
})
|
|
}))
|
|
defer srv.Close()
|
|
|
|
zs, err := c.ListZones(context.Background(), creds())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if gotToken != "secret-token" {
|
|
t.Fatalf("token not sent, got %q", gotToken)
|
|
}
|
|
if len(zs) != 2 || zs[0].ID != "z1" || zs[1].Name != "test.org." {
|
|
t.Fatalf("unexpected zones: %+v", zs)
|
|
}
|
|
}
|
|
|
|
func TestGetRecordsMapsRRSet(t *testing.T) {
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "r1", "name": "example.com.", "type": "MX", "ttl": 3600,
|
|
"records": []map[string]any{{"content": "10 mx1.example.com.", "disabled": false}}},
|
|
{"id": "r2", "name": "www.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "1.2.3.4"}, {"content": "5.6.7.8", "disabled": true}}},
|
|
},
|
|
"next_offset": 0,
|
|
})
|
|
}))
|
|
defer srv.Close()
|
|
|
|
recs, err := c.GetRecords(context.Background(), creds(), "z1")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(recs) != 2 {
|
|
t.Fatalf("want 2 records, got %d", len(recs))
|
|
}
|
|
var a model.Record
|
|
for _, r := range recs {
|
|
if r.Type == model.A {
|
|
a = r
|
|
}
|
|
}
|
|
// disabled record dropped -> only one value
|
|
if len(a.Values) != 1 || a.Values[0] != "1.2.3.4" {
|
|
t.Fatalf("disabled record must be skipped, got %+v", a.Values)
|
|
}
|
|
}
|
|
|
|
func TestApplyChangesRoutesVerbs(t *testing.T) {
|
|
type call struct{ method, path string }
|
|
var calls []call
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
// GET rrset -> return existing set with ids for update/delete resolution
|
|
if r.Method == http.MethodGet {
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "up1", "name": "b.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "9.9.9.9"}}},
|
|
{"id": "del1", "name": "d.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "4.4.4.4"}}},
|
|
},
|
|
"next_offset": 0,
|
|
})
|
|
return
|
|
}
|
|
calls = append(calls, call{r.Method, r.URL.Path})
|
|
w.WriteHeader(http.StatusOK)
|
|
}))
|
|
defer srv.Close()
|
|
|
|
add := model.Record{Type: model.A, Name: "c.example.com.", TTL: 300, Values: []string{"3.3.3.3"}}
|
|
updDesired := model.Record{Type: model.A, Name: "b.example.com.", TTL: 300, Values: []string{"2.2.2.2"}}
|
|
delActual := model.Record{Type: model.A, Name: "d.example.com.", TTL: 300, Values: []string{"4.4.4.4"}}
|
|
ns := model.Record{Type: model.NS, Name: "example.com.", TTL: 3600, Values: []string{"ns1.example.com."}}
|
|
|
|
cs := diff.Changeset{Diffs: []diff.RecordDiff{
|
|
{Kind: diff.Add, Type: add.Type, Name: add.Name, Desired: &add},
|
|
{Kind: diff.Update, Type: updDesired.Type, Name: updDesired.Name, Desired: &updDesired},
|
|
{Kind: diff.Delete, Type: delActual.Type, Name: delActual.Name, Actual: &delActual},
|
|
{Kind: diff.Update, Type: ns.Type, Name: ns.Name, Desired: &ns, ReadOnly: true}, // must be skipped
|
|
}}
|
|
|
|
if err := c.ApplyChanges(context.Background(), creds(), "z1", cs); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
want := map[string]bool{
|
|
"POST /zones/z1/rrset": true,
|
|
"PATCH /zones/z1/rrset/up1": true,
|
|
"DELETE /zones/z1/rrset/del1": true,
|
|
}
|
|
if len(calls) != len(want) {
|
|
t.Fatalf("want %d calls, got %v", len(want), calls)
|
|
}
|
|
for _, cl := range calls {
|
|
if !want[cl.method+" "+cl.path] {
|
|
t.Fatalf("unexpected call %s %s", cl.method, cl.path)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Global Constraint: id not found for Update -> error, and mutation must not proceed.
|
|
func TestApplyChangesUpdateIDNotFoundReturnsErrorAndSkipsMutation(t *testing.T) {
|
|
var calls []string
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method == http.MethodGet {
|
|
// empty existing rrset set -> nothing resolves to an id
|
|
json.NewEncoder(w).Encode(map[string]any{"result": []map[string]any{}, "next_offset": 0})
|
|
return
|
|
}
|
|
calls = append(calls, r.Method+" "+r.URL.Path)
|
|
w.WriteHeader(http.StatusOK)
|
|
}))
|
|
defer srv.Close()
|
|
|
|
missing := model.Record{Type: model.A, Name: "missing.example.com.", TTL: 300, Values: []string{"1.1.1.1"}}
|
|
add := model.Record{Type: model.A, Name: "new.example.com.", TTL: 300, Values: []string{"2.2.2.2"}}
|
|
|
|
cs := diff.Changeset{Diffs: []diff.RecordDiff{
|
|
{Kind: diff.Update, Type: missing.Type, Name: missing.Name, Desired: &missing},
|
|
{Kind: diff.Add, Type: add.Type, Name: add.Name, Desired: &add},
|
|
}}
|
|
|
|
err := c.ApplyChanges(context.Background(), creds(), "z1", cs)
|
|
if err == nil {
|
|
t.Fatal("expected non-nil error when update rrset id is not found")
|
|
}
|
|
if len(calls) != 0 {
|
|
t.Fatalf("expected no mutating requests to be sent, got %v", calls)
|
|
}
|
|
}
|
|
|
|
// Global Constraint: id not found for Delete -> error.
|
|
func TestApplyChangesDeleteIDNotFoundReturnsError(t *testing.T) {
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method == http.MethodGet {
|
|
json.NewEncoder(w).Encode(map[string]any{"result": []map[string]any{}, "next_offset": 0})
|
|
return
|
|
}
|
|
t.Fatalf("unexpected mutating call %s %s, delete should have errored before reaching HTTP", r.Method, r.URL.Path)
|
|
}))
|
|
defer srv.Close()
|
|
|
|
missing := model.Record{Type: model.A, Name: "missing.example.com.", TTL: 300, Values: []string{"1.1.1.1"}}
|
|
cs := diff.Changeset{Diffs: []diff.RecordDiff{
|
|
{Kind: diff.Delete, Type: missing.Type, Name: missing.Name, Actual: &missing},
|
|
}}
|
|
|
|
if err := c.ApplyChanges(context.Background(), creds(), "z1", cs); err == nil {
|
|
t.Fatal("expected non-nil error when delete rrset id is not found")
|
|
}
|
|
}
|
|
|
|
// Global Constraint: X-Auth-Token must be sent on mutating requests (POST/PATCH/DELETE), not only on GET.
|
|
func TestApplyChangesSendsTokenOnMutations(t *testing.T) {
|
|
var tokens []string
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method == http.MethodGet {
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "up1", "name": "b.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "9.9.9.9"}}},
|
|
{"id": "del1", "name": "d.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "4.4.4.4"}}},
|
|
},
|
|
"next_offset": 0,
|
|
})
|
|
return
|
|
}
|
|
tokens = append(tokens, r.Header.Get("X-Auth-Token"))
|
|
w.WriteHeader(http.StatusOK)
|
|
}))
|
|
defer srv.Close()
|
|
|
|
add := model.Record{Type: model.A, Name: "c.example.com.", TTL: 300, Values: []string{"3.3.3.3"}}
|
|
updDesired := model.Record{Type: model.A, Name: "b.example.com.", TTL: 300, Values: []string{"2.2.2.2"}}
|
|
delActual := model.Record{Type: model.A, Name: "d.example.com.", TTL: 300, Values: []string{"4.4.4.4"}}
|
|
|
|
cs := diff.Changeset{Diffs: []diff.RecordDiff{
|
|
{Kind: diff.Add, Type: add.Type, Name: add.Name, Desired: &add},
|
|
{Kind: diff.Update, Type: updDesired.Type, Name: updDesired.Name, Desired: &updDesired},
|
|
{Kind: diff.Delete, Type: delActual.Type, Name: delActual.Name, Actual: &delActual},
|
|
}}
|
|
|
|
if err := c.ApplyChanges(context.Background(), creds(), "z1", cs); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(tokens) != 3 {
|
|
t.Fatalf("expected 3 mutating requests (POST/PATCH/DELETE), got %d", len(tokens))
|
|
}
|
|
for _, tok := range tokens {
|
|
if tok != "secret-token" {
|
|
t.Fatalf("expected X-Auth-Token %q on mutation, got %q", "secret-token", tok)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Global Constraint: multi-page pagination must accumulate records across pages without an infinite loop.
|
|
func TestListZonesPaginatesAcrossMultiplePages(t *testing.T) {
|
|
var offsets []string
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
offset := r.URL.Query().Get("offset")
|
|
offsets = append(offsets, offset)
|
|
if len(offsets) > 2 {
|
|
t.Fatalf("too many requests, possible infinite pagination loop: %v", offsets)
|
|
}
|
|
switch offset {
|
|
case "0":
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{{"id": "z1", "name": "first.example.com."}},
|
|
"next_offset": 1000,
|
|
})
|
|
case "1000":
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{{"id": "z2", "name": "second.example.com."}},
|
|
"next_offset": 0,
|
|
})
|
|
default:
|
|
t.Fatalf("unexpected offset %q", offset)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
zs, err := c.ListZones(context.Background(), creds())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(offsets) != 2 {
|
|
t.Fatalf("expected exactly 2 page requests, got %d: %v", len(offsets), offsets)
|
|
}
|
|
if len(zs) != 2 || zs[0].ID != "z1" || zs[1].ID != "z2" {
|
|
t.Fatalf("expected accumulated zones from both pages, got %+v", zs)
|
|
}
|
|
}
|
|
|
|
// Global Constraint: listRRSets (via GetRecords) must paginate across multiple pages,
|
|
// accumulating records from every page, and must stop as soon as next_offset is 0 —
|
|
// no third request should ever be issued.
|
|
func TestGetRecordsPaginatesAcrossMultiplePages(t *testing.T) {
|
|
var offsets []string
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
offset := r.URL.Query().Get("offset")
|
|
offsets = append(offsets, offset)
|
|
if len(offsets) > 2 {
|
|
t.Fatalf("too many requests, possible infinite pagination loop: %v", offsets)
|
|
}
|
|
switch offset {
|
|
case "0":
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "r1", "name": "a.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "1.1.1.1"}}},
|
|
},
|
|
"next_offset": 1000,
|
|
})
|
|
case "1000":
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "r2", "name": "b.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "2.2.2.2"}}},
|
|
},
|
|
"next_offset": 0,
|
|
})
|
|
default:
|
|
t.Fatalf("unexpected offset %q", offset)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
recs, err := c.GetRecords(context.Background(), creds(), "z1")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(offsets) != 2 {
|
|
t.Fatalf("expected exactly 2 page requests, got %d: %v", len(offsets), offsets)
|
|
}
|
|
if len(recs) != 2 {
|
|
t.Fatalf("expected accumulated records from both pages, got %+v", recs)
|
|
}
|
|
names := map[string]bool{recs[0].Name: true, recs[1].Name: true}
|
|
if !names["a.example.com."] || !names["b.example.com."] {
|
|
t.Fatalf("expected records from both pages, got %+v", recs)
|
|
}
|
|
}
|
|
|
|
// Global Constraint: ApplyChanges must not panic on a Changeset with a nil Desired
|
|
// record for Add/Update, and must instead return a clear error.
|
|
func TestApplyChangesAddWithNilDesiredReturnsErrorNoPanic(t *testing.T) {
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method == http.MethodGet {
|
|
json.NewEncoder(w).Encode(map[string]any{"result": []map[string]any{}, "next_offset": 0})
|
|
return
|
|
}
|
|
t.Fatalf("unexpected mutating call %s %s, nil Desired should have errored before reaching HTTP", r.Method, r.URL.Path)
|
|
}))
|
|
defer srv.Close()
|
|
|
|
cs := diff.Changeset{Diffs: []diff.RecordDiff{
|
|
{Kind: diff.Add, Type: model.A, Name: "nil-desired.example.com.", Desired: nil},
|
|
}}
|
|
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Fatalf("ApplyChanges panicked on nil Desired: %v", r)
|
|
}
|
|
}()
|
|
|
|
err := c.ApplyChanges(context.Background(), creds(), "z1", cs)
|
|
if err == nil {
|
|
t.Fatal("expected non-nil error for Add diff with nil Desired")
|
|
}
|
|
}
|
|
|
|
// Global Constraint: New() must configure the default base URL and a 30s HTTP timeout.
|
|
func TestNewDefaults(t *testing.T) {
|
|
c := New()
|
|
if c.BaseURL != DefaultBaseURL {
|
|
t.Fatalf("BaseURL = %q, want %q", c.BaseURL, DefaultBaseURL)
|
|
}
|
|
if c.HTTP == nil {
|
|
t.Fatal("HTTP client must not be nil")
|
|
}
|
|
if c.HTTP.Timeout != 30*time.Second {
|
|
t.Fatalf("HTTP.Timeout = %v, want %v", c.HTTP.Timeout, 30*time.Second)
|
|
}
|
|
}
|
|
|
|
// Global Constraint: if the API returns a NextOffset that does not advance past the
|
|
// current offset (stuck or regressing), even with a non-empty page, ListZones must
|
|
// stop pagination instead of looping forever on the same/earlier offset.
|
|
func TestListZonesStopsOnNonAdvancingNextOffset(t *testing.T) {
|
|
var requests int
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
requests++
|
|
if requests > 5 {
|
|
t.Fatalf("too many requests, possible infinite pagination loop on stuck offset")
|
|
}
|
|
offset := r.URL.Query().Get("offset")
|
|
switch offset {
|
|
case "0":
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{{"id": "z1", "name": "first.example.com."}},
|
|
"next_offset": 1000,
|
|
})
|
|
case "1000":
|
|
// Buggy/malicious API: next_offset does not advance past current offset,
|
|
// yet the page is non-empty.
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{{"id": "z2", "name": "second.example.com."}},
|
|
"next_offset": 1000,
|
|
})
|
|
default:
|
|
t.Fatalf("unexpected offset %q", offset)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
zs, err := c.ListZones(context.Background(), creds())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if requests != 2 {
|
|
t.Fatalf("expected exactly 2 requests before stopping on stuck offset, got %d", requests)
|
|
}
|
|
if len(zs) != 2 || zs[0].ID != "z1" || zs[1].ID != "z2" {
|
|
t.Fatalf("expected zones accumulated from both pages before stopping, got %+v", zs)
|
|
}
|
|
}
|
|
|
|
// Global Constraint: same guard applies to listRRSets (exercised via GetRecords) —
|
|
// a non-advancing NextOffset on a non-empty page must stop pagination, not loop forever.
|
|
func TestGetRecordsStopsOnNonAdvancingNextOffset(t *testing.T) {
|
|
var requests int
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
requests++
|
|
if requests > 5 {
|
|
t.Fatalf("too many requests, possible infinite pagination loop on stuck offset")
|
|
}
|
|
offset := r.URL.Query().Get("offset")
|
|
switch offset {
|
|
case "0":
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "r1", "name": "a.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "1.1.1.1"}}},
|
|
},
|
|
"next_offset": 1000,
|
|
})
|
|
case "1000":
|
|
// Buggy/malicious API: next_offset regresses below current offset,
|
|
// yet the page is non-empty.
|
|
json.NewEncoder(w).Encode(map[string]any{
|
|
"result": []map[string]any{
|
|
{"id": "r2", "name": "b.example.com.", "type": "A", "ttl": 300,
|
|
"records": []map[string]any{{"content": "2.2.2.2"}}},
|
|
},
|
|
"next_offset": 500,
|
|
})
|
|
default:
|
|
t.Fatalf("unexpected offset %q", offset)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
recs, err := c.GetRecords(context.Background(), creds(), "z1")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if requests != 2 {
|
|
t.Fatalf("expected exactly 2 requests before stopping on stuck/regressing offset, got %d", requests)
|
|
}
|
|
if len(recs) != 2 {
|
|
t.Fatalf("expected records accumulated from both pages before stopping, got %+v", recs)
|
|
}
|
|
}
|
|
|
|
// Global Constraint: HTTP errors (status >= 300) must surface a non-nil error whose text
|
|
// includes the method/path/status (or response body) for diagnosability.
|
|
func TestListZonesHTTPErrorIncludesMethodPathStatus(t *testing.T) {
|
|
c, srv := newTestClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("zone not found"))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
_, err := c.ListZones(context.Background(), creds())
|
|
if err == nil {
|
|
t.Fatal("expected non-nil error on non-2xx response")
|
|
}
|
|
msg := err.Error()
|
|
if !strings.Contains(msg, http.MethodGet) {
|
|
t.Fatalf("error should mention HTTP method %q, got %q", http.MethodGet, msg)
|
|
}
|
|
if !strings.Contains(msg, "404") {
|
|
t.Fatalf("error should mention status code 404, got %q", msg)
|
|
}
|
|
if !strings.Contains(msg, "/zones") {
|
|
t.Fatalf("error should mention request path, got %q", msg)
|
|
}
|
|
if !strings.Contains(msg, "zone not found") {
|
|
t.Fatalf("error should include response body, got %q", msg)
|
|
}
|
|
}
|