enable delete function method

Signed-off-by: Nitishkumar Singh <[email protected]>

Author: nitishkumar71

client.go

@@ -2,7 +2,6 @@ package sdk
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -246,15 +245,20 @@ func (s *Client) deploy(method string, spec types.FunctionDeployment) (int, erro
 		body, _ = io.ReadAll(res.Body)
 	}
 
-	if res.StatusCode != http.StatusAccepted {
-		return res.StatusCode, fmt.Errorf("unexpected status code: %d, message: %s", res.StatusCode, string(body))
-	}
+	switch res.StatusCode {
+	case http.StatusAccepted, http.StatusOK, http.StatusCreated:
+		return res.StatusCode, nil
+
+	case http.StatusUnauthorized:
+		return res.StatusCode, fmt.Errorf("unauthorized action, please setup authentication for this server")
 
-	return res.StatusCode, nil
+	default:
+		return res.StatusCode, fmt.Errorf("unexpected status code: %d, message: %q", res.StatusCode, string(body))
+	}
 }
 
 // ScaleFunction scales a function to a number of replicas
-func (s *Client) ScaleFunction(ctx context.Context, functionName, namespace string, replicas uint64) error {
+func (s *Client) ScaleFunction(functionName, namespace string, replicas uint64) error {
 
 	scaleReq := types.ScaleServiceRequest{
 		ServiceName: functionName,
@@ -314,3 +318,61 @@ func (s *Client) ScaleFunction(ctx context.Context, functionName, namespace stri
 	}
 	return nil
 }
+
+// DeleteFunction deletes a function
+func (s *Client) DeleteFunction(functionName, namespace string) error {
+
+	delReq := types.DeleteFunctionRequest{
+		FunctionName: functionName,
+		Namespace:    namespace,
+	}
+
+	var err error
+
+	bodyBytes, _ := json.Marshal(delReq)
+	bodyReader := bytes.NewReader(bodyBytes)
+
+	u := s.GatewayURL
+	u.Path = "/system/functions"
+
+	req, err := http.NewRequest(http.MethodDelete, u.String(), bodyReader)
+	if err != nil {
+		return fmt.Errorf("cannot connect to OpenFaaS on URL: %s, error: %s", u.String(), err)
+	}
+
+	if s.ClientAuth != nil {
+		if err := s.ClientAuth.Set(req); err != nil {
+			return fmt.Errorf("unable to set Authorization header: %w", err)
+		}
+	}
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("cannot connect to OpenFaaS on URL: %s, error: %s", s.GatewayURL, err)
+
+	}
+
+	if res.Body != nil {
+		defer res.Body.Close()
+	}
+
+	switch res.StatusCode {
+	case http.StatusAccepted, http.StatusOK, http.StatusCreated:
+		break
+
+	case http.StatusNotFound:
+		return fmt.Errorf("function %s not found", functionName)
+
+	case http.StatusUnauthorized:
+		return fmt.Errorf("unauthorized action, please setup authentication for this server")
+
+	default:
+		var err error
+		bytesOut, err := io.ReadAll(res.Body)
+		if err != nil {
+			return err
+		}
+
+		return fmt.Errorf("server returned unexpected status code %d, message: %q", res.StatusCode, string(bytesOut))
+	}
+	return nil
+}

client_test.go

@@ -1,10 +1,14 @@
 package sdk
 
 import (
+	"errors"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"testing"
+
+	"github.com/openfaas/faas-provider/types"
 )
 
 func TestSdk_GetNamespaces_TwoNamespaces(t *testing.T) {
@@ -70,3 +74,132 @@ func TestSdk_GetNamespaces_NoNamespaces(t *testing.T) {
 		t.Fatalf("want %d namespaces, got: %d", len(wantNS), gotNS)
 	}
 }
+
+func TestSdk_DeployFunction(t *testing.T) {
+	funcName := "funct1"
+	nsName := "ns1"
+	tests := []struct {
+		name         string
+		functionName string
+		namespace    string
+		err          error
+		handler      func(rw http.ResponseWriter, req *http.Request)
+	}{
+		{
+			name:         "function deployed",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				rw.WriteHeader(http.StatusOK)
+			},
+		},
+		{
+			name:         "function will bedeployed",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				rw.WriteHeader(http.StatusAccepted)
+			},
+		},
+		{
+			name:         "client not authorized",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				rw.WriteHeader(http.StatusUnauthorized)
+			},
+			err: fmt.Errorf("unauthorized action, please setup authentication for this server"),
+		},
+		{
+			name:         "unknown error",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				http.Error(rw, "unknown error", http.StatusInternalServerError)
+			},
+			err: fmt.Errorf("unexpected status code: %d, message: %q", http.StatusInternalServerError, "unknown error\n"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			s := httptest.NewServer(http.HandlerFunc(test.handler))
+
+			sU, _ := url.Parse(s.URL)
+
+			client := NewClient(sU, nil, http.DefaultClient)
+			_, err := client.Deploy(types.FunctionDeployment{
+				Service:   funcName,
+				Image:     fmt.Sprintf("docker.io/openfaas/%s:latest", funcName),
+				Namespace: nsName,
+			})
+
+			if !errors.Is(err, test.err) && err.Error() != test.err.Error() {
+				t.Fatalf("wanted %s, but got: %s", test.err, err)
+			}
+		})
+	}
+}
+
+func TestSdk_DeleteFunction(t *testing.T) {
+	funcName := "funct1"
+	nsName := "ns1"
+	tests := []struct {
+		name         string
+		functionName string
+		namespace    string
+		err          error
+		handler      func(rw http.ResponseWriter, req *http.Request)
+	}{
+		{
+			name:         "function deleted",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				rw.WriteHeader(http.StatusAccepted)
+			},
+		},
+		{
+			name:         "function not found",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				rw.WriteHeader(http.StatusNotFound)
+			},
+			err: fmt.Errorf("function %s not found", funcName),
+		},
+		{
+			name:         "client not authorized",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				rw.WriteHeader(http.StatusUnauthorized)
+			},
+			err: fmt.Errorf("unauthorized action, please setup authentication for this server"),
+		},
+		{
+			name:         "unknown error",
+			functionName: funcName,
+			namespace:    nsName,
+			handler: func(rw http.ResponseWriter, req *http.Request) {
+				http.Error(rw, "unknown error", http.StatusInternalServerError)
+			},
+			err: fmt.Errorf("server returned unexpected status code %d, message: %q", http.StatusInternalServerError, string("unknown error\n")),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			s := httptest.NewServer(http.HandlerFunc(test.handler))
+
+			sU, _ := url.Parse(s.URL)
+
+			client := NewClient(sU, nil, http.DefaultClient)
+			err := client.DeleteFunction(test.functionName, test.namespace)
+
+			if !errors.Is(err, test.err) && err.Error() != test.err.Error() {
+				t.Fatalf("wanted %s, but got: %s", test.err, err)
+			}
+		})
+	}
+}