Webhook provider

docs/tutorials/webhook-provider.md

@@ -22,7 +22,7 @@ The following table represents the methods to implement mapped to their HTTP met
 | AdjustEndpoints | POST | /adjustendpoints |
 | ApplyChanges | POST | /records |
 
-ExternalDNS will also make requests to the `/` endpoint for negotatiation and for deseliarization of the `DomainFilter`.
+ExternalDNS will also make requests to the `/` endpoint for negotiation and for deserialization of the `DomainFilter`.
 
 The server needs to respond to those requests by reading the `Accept` header and responding with a corresponding `Content-Type` header specifying the supported media type format and version.
 

provider/webhook/httpapi_test.go

@@ -20,6 +20,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/http"
 	"net/http/httptest"
@@ -31,34 +32,84 @@ import (
 	"sigs.k8s.io/external-dns/plan"
 )
 
-type FakeWebhookProvider struct{}
+var records []*endpoint.Endpoint
+
+type FakeWebhookProvider struct {
+	err          error
+	domainFilter endpoint.DomainFilter
+}
 
 func (p FakeWebhookProvider) Records(ctx context.Context) ([]*endpoint.Endpoint, error) {
-	return []*endpoint.Endpoint{}, nil
+	if p.err != nil {
+		return nil, p.err
+	}
+	return records, nil
 }
 
 func (p FakeWebhookProvider) ApplyChanges(ctx context.Context, changes *plan.Changes) error {
+	if p.err != nil {
+		return p.err
+	}
+	records = append(records, changes.Create...)
 	return nil
 }
 
 func (p FakeWebhookProvider) AdjustEndpoints(endpoints []*endpoint.Endpoint) ([]*endpoint.Endpoint, error) {
+	// for simplicity, we do not adjust endpoints in this test
+	if p.err != nil {
+		return nil, p.err
+	}
 	return endpoints, nil
 }
 
 func (p FakeWebhookProvider) GetDomainFilter() endpoint.DomainFilter {
-	return endpoint.DomainFilter{}
+	return p.domainFilter
+}
+
+func TestMain(m *testing.M) {
+	records = []*endpoint.Endpoint{
+		{
+			DNSName:    "foo.bar.com",
+			RecordType: "A",
+		},
+	}
+	m.Run()
 }
 
 func TestRecordsHandlerRecords(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/records", nil)
 	w := httptest.NewRecorder()
 
 	providerAPIServer := &WebhookServer{
-		provider: &FakeWebhookProvider{},
+		provider: &FakeWebhookProvider{
+			domainFilter: endpoint.NewDomainFilter([]string{"foo.bar.com"}),
+		},
 	}
 	providerAPIServer.recordsHandler(w, req)
 	res := w.Result()
 	require.Equal(t, http.StatusOK, res.StatusCode)
+	// require that the res has the same endpoints as the records slice
+	defer res.Body.Close()
+	require.NotNil(t, res.Body)
+	endpoints := []*endpoint.Endpoint{}
+	if err := json.NewDecoder(res.Body).Decode(&endpoints); err != nil {
+		t.Errorf("Failed to decode response body: %s", err.Error())
+	}
+	require.Equal(t, records, endpoints)
+}
+
+func TestRecordsHandlerRecordsWithErrors(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/records", nil)
+	w := httptest.NewRecorder()
+
+	providerAPIServer := &WebhookServer{
+		provider: &FakeWebhookProvider{
+			err: fmt.Errorf("error"),
+		},
+	}
+	providerAPIServer.recordsHandler(w, req)
+	res := w.Result()
+	require.Equal(t, http.StatusInternalServerError, res.StatusCode)
 }
 
 func TestRecordsHandlerApplyChangesWithBadRequest(t *testing.T) {
@@ -99,6 +150,46 @@ func TestRecordsHandlerApplyChangesWithValidRequest(t *testing.T) {
 	require.Equal(t, http.StatusNoContent, res.StatusCode)
 }
 
+func TestRecordsHandlerApplyChangesWithErrors(t *testing.T) {
+	changes := &plan.Changes{
+		Create: []*endpoint.Endpoint{
+			{
+				DNSName:    "foo.bar.com",
+				RecordType: "A",
+				Targets:    endpoint.Targets{},
+			},
+		},
+	}
+	j, err := json.Marshal(changes)
+	require.NoError(t, err)
+
+	reader := bytes.NewReader(j)
+
+	req := httptest.NewRequest(http.MethodPost, "/applychanges", reader)
+	w := httptest.NewRecorder()
+
+	providerAPIServer := &WebhookServer{
+		provider: &FakeWebhookProvider{
+			err: fmt.Errorf("error"),
+		},
+	}
+	providerAPIServer.recordsHandler(w, req)
+	res := w.Result()
+	require.Equal(t, http.StatusInternalServerError, res.StatusCode)
+}
+
+func TestRecordsHandlerWithWrongHTTPMethod(t *testing.T) {
+	req := httptest.NewRequest(http.MethodPut, "/records", nil)
+	w := httptest.NewRecorder()
+
+	providerAPIServer := &WebhookServer{
+		provider: &FakeWebhookProvider{},
+	}
+	providerAPIServer.recordsHandler(w, req)
+	res := w.Result()
+	require.Equal(t, http.StatusBadRequest, res.StatusCode)
+}
+
 func TestAdjustEndpointsHandlerWithInvalidRequest(t *testing.T) {
 	req := httptest.NewRequest(http.MethodPost, "/adjustendpoints", nil)
 	w := httptest.NewRecorder()
@@ -117,7 +208,7 @@ func TestAdjustEndpointsHandlerWithInvalidRequest(t *testing.T) {
 	require.Equal(t, http.StatusBadRequest, res.StatusCode)
 }
 
-func TestAdjustEndpointsWithValidRequest(t *testing.T) {
+func TestAdjustEndpointsHandlerWithValidRequest(t *testing.T) {
 	pve := []*endpoint.Endpoint{
 		{
 			DNSName:    "foo.bar.com",
@@ -143,6 +234,34 @@ func TestAdjustEndpointsWithValidRequest(t *testing.T) {
 	require.NotNil(t, res.Body)
 }
 
+func TestAdjustEndpointsHandlerWithError(t *testing.T) {
+	pve := []*endpoint.Endpoint{
+		{
+			DNSName:    "foo.bar.com",
+			RecordType: "A",
+			Targets:    endpoint.Targets{},
+			RecordTTL:  0,
+		},
+	}
+
+	j, err := json.Marshal(pve)
+	require.NoError(t, err)
+
+	reader := bytes.NewReader(j)
+	req := httptest.NewRequest(http.MethodPost, "/adjustendpoints", reader)
+	w := httptest.NewRecorder()
+
+	providerAPIServer := &WebhookServer{
+		provider: &FakeWebhookProvider{
+			err: fmt.Errorf("error"),
+		},
+	}
+	providerAPIServer.adjustEndpointsHandler(w, req)
+	res := w.Result()
+	require.Equal(t, http.StatusInternalServerError, res.StatusCode)
+	require.NotNil(t, res.Body)
+}
+
 func TestStartHTTPApi(t *testing.T) {
 	startedChan := make(chan struct{})
 	go StartHTTPApi(FakeWebhookProvider{}, startedChan, 5*time.Second, 10*time.Second, "127.0.0.1:8887")

provider/webhook/webhook.go

@@ -240,7 +240,7 @@ func (p WebhookProvider) AdjustEndpoints(e []*endpoint.Endpoint) ([]*endpoint.En
 	if resp.StatusCode != http.StatusOK {
 		adjustEndpointsErrorsGauge.Inc()
 		log.Debugf("Failed to AdjustEndpoints with code %d", resp.StatusCode)
-		return nil, err
+		return nil, fmt.Errorf("failed to AdjustEndpoints with code %d", resp.StatusCode)
 	}
 
 	if err := json.NewDecoder(resp.Body).Decode(&endpoints); err != nil {

provider/webhook/webhook_test.go

@@ -46,17 +46,20 @@ func TestInvalidDomainFilter(t *testing.T) {
 }
 
 func TestValidDomainfilter(t *testing.T) {
+	// initialize domanin filter
+	domainFilter := endpoint.NewDomainFilter([]string{"example.com"})
 	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path == "/" {
 			w.Header().Set(contentTypeHeader, mediaTypeFormatAndVersion)
-			w.Write([]byte(`{}`))
+			json.NewEncoder(w).Encode(domainFilter)
 			return
 		}
 	}))
 	defer svr.Close()
 
-	_, err := NewWebhookProvider(svr.URL)
+	p, err := NewWebhookProvider(svr.URL)
 	require.NoError(t, err)
+	require.Equal(t, p.GetDomainFilter(), endpoint.NewDomainFilter([]string{"example.com"}))
 }
 
 func TestRecords(t *testing.T) {
@@ -66,6 +69,7 @@ func TestRecords(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
+		require.Equal(t, "/records", r.URL.Path)
 		w.Write([]byte(`[{
 			"dnsName" : "test.example.com"
 		}]`))
@@ -82,6 +86,24 @@ func TestRecords(t *testing.T) {
 	}}, endpoints)
 }
 
+func TestRecordsWithErrors(t *testing.T) {
+	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/" {
+			w.Header().Set(contentTypeHeader, mediaTypeFormatAndVersion)
+			w.Write([]byte(`{}`))
+			return
+		}
+		require.Equal(t, "/records", r.URL.Path)
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer svr.Close()
+
+	provider, err := NewWebhookProvider(svr.URL)
+	require.NoError(t, err)
+	_, err = provider.Records(context.Background())
+	require.NotNil(t, err)
+}
+
 func TestApplyChanges(t *testing.T) {
 	successfulApplyChanges := true
 	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -90,6 +112,7 @@ func TestApplyChanges(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
+		require.Equal(t, "/records", r.URL.Path)
 		if successfulApplyChanges {
 			w.WriteHeader(http.StatusNoContent)
 		} else {
@@ -116,6 +139,8 @@ func TestAdjustEndpoints(t *testing.T) {
 			w.Write([]byte(`{}`))
 			return
 		}
+		require.Equal(t, "/adjustendpoints", r.URL.Path)
+
 		var endpoints []*endpoint.Endpoint
 		defer r.Body.Close()
 		b, err := io.ReadAll(r.Body)
@@ -158,5 +183,32 @@ func TestAdjustEndpoints(t *testing.T) {
 			"",
 		},
 	}}, adjustedEndpoints)
+}
+
+func TestAdjustendpointsWithError(t *testing.T) {
+	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/" {
+			w.Header().Set(contentTypeHeader, mediaTypeFormatAndVersion)
+			w.Write([]byte(`{}`))
+			return
+		}
+		require.Equal(t, "/adjustendpoints", r.URL.Path)
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer svr.Close()
 
+	provider, err := NewWebhookProvider(svr.URL)
+	require.NoError(t, err)
+	endpoints := []*endpoint.Endpoint{
+		{
+			DNSName:    "test.example.com",
+			RecordTTL:  10,
+			RecordType: "A",
+			Targets: endpoint.Targets{
+				"",
+			},
+		},
+	}
+	_, err = provider.AdjustEndpoints(endpoints)
+	require.Error(t, err)
 }