added readme and fixed some bugs

Author: UrielCohen456

README.md

@@ -1,8 +1,8 @@
-# Argocd Executor Plugin
-**IN ACTIVE DEVELOPMENT**
-
-This is an ArgoCD plugin that allows you to interact with an argocd instance of your choice.
-This is meant to be easily available and to be used in your ci/cd needs.
+<div align="center">
+  <h1 align="center">Argocd Executor Plugin</h1>
+  <p align="center">An <a href="https://github.com/argoproj/argo-workflows/blob/master/docs/executor_plugins.md">Executor Plugin</a> for <a href="https://argoproj.github.io/argo-workflows/">Argo Workflows</a> that lets you interact with ArgoCD servers </br>
+  <b>In Active Development</b></p>
+</div>
 
 ## Example Usage
 
@@ -23,8 +23,11 @@ spec:
                 project: guestbook
                 apps:
                   - guestbook
+                  - guestbook-backend
 ```
 
+</br>
+
 ## Getting Started
 
 Head to the [scripts](scripts/README.md) directory to find out how to get the project up and running on your local machine for development and testing purposes.
@@ -37,6 +40,8 @@ You will need to have a working [Argo Workflows](https://argoproj.github.io/argo
 
 Read how to install the plugin in your Argo Workflows instance [here](out/README.md).
 
+</br>
+
 ## Contributing
 
 Currently I am developing this on my own as my interest in workflow plugins is growing. <br>

cmd/argocd-plugin/main.go

@@ -7,7 +7,7 @@ import (
 	"k8s.io/client-go/rest"
 
 	"github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/common"
-	argocd "github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/internal/argocd-plugin"
+	plugin "github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/internal/argocd-plugin"
 )
 
 func main() {
@@ -21,6 +21,6 @@ func main() {
 		panic(err.Error())
 	}
 
-	http.HandleFunc("/api/v1/template.execute",  argocd.ArgocdPlugin(client, common.Namespace()))
+	http.HandleFunc("/api/v1/template.execute",  plugin.ArgocdPlugin(client, common.Namespace()))
 	http.ListenAndServe(":4355", nil)
 }

internal/argocd-plugin/plugin.go

@@ -2,50 +2,64 @@ package argocd
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"net/http"
 
 	"k8s.io/client-go/kubernetes"
 	// metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
- 	"github.com/argoproj/argo-workflows/v3/pkg/plugins/executor"
+	"github.com/argoproj/argo-workflows/v3/pkg/apis/workflow/v1alpha1"
+	"github.com/argoproj/argo-workflows/v3/pkg/plugins/executor"
+)
+
+var (
+	ErrWrongContentType		= errors.New("Content-Type header is not set to 'appliaction/json'")
+	ErrReadingBody		 		= errors.New("Couldn't read request body")
+	ErrMarshallingBody		= errors.New("Couldn't unmrashal request body")
 )
 
 func ArgocdPlugin(kubeClient kubernetes.Interface, namespace string) func(w http.ResponseWriter, req *http.Request) {
 	return func(w http.ResponseWriter, req *http.Request) {
-		if req.Body == http.NoBody {
-			log.Printf("No request body present")
-			http.Error(w, "No request body present", http.StatusBadRequest)
+		if header := req.Header.Get("Content-Type"); header == "" || header != "application/json" {
+			log.Print(ErrWrongContentType)
+			http.Error(w, ErrWrongContentType.Error(), http.StatusBadRequest)
 			return
 		}
 
 		body, err := ioutil.ReadAll(req.Body)
 		if err != nil {
-			log.Printf("Error reading body: %v", err)
-			http.Error(w, "couldn't read body", http.StatusBadRequest)
+			log.Print(ErrReadingBody)
+			http.Error(w, ErrReadingBody.Error(), http.StatusBadRequest)
 			return
 		}
 
+		log.Printf("Recieved body: %v", string(body))
+
 		args := executor.ExecuteTemplateArgs{}
-		if err := args.Template.Unmarshal(body); err != nil {
-			log.Printf("Error unmrashalling body: %v", err)
-			http.Error(w, "couldn't unmrashal body", http.StatusBadRequest)
+		if err := json.Unmarshal(body, &args); err != nil {
+			log.Print(ErrMarshallingBody)
+			http.Error(w, ErrMarshallingBody.Error(), http.StatusBadRequest)
 			return
 		}
-		log.Printf("%v", args)
+
+		log.Printf("Received args: %v", args)
 
 		// channel, text, err := parsPayload(args)
 		// if err != nil {
 		// 	w.WriteHeader(http.StatusBadRequest)
 		// 	return
 		// }
 
-		resp := make(map[string]map[string]string)
-		resp["node"] = make(map[string]string)
-		resp["node"]["phase"] = "Succeeded"
-		resp["node"]["message"] = fmt.Sprintf("ArgoCD command succeeded: %s", namespace)
-		resp["node"]["debug"] = fmt.Sprint(args) 
+		resp := executor.ExecuteTemplateResponse{
+			Body: executor.ExecuteTemplateReply{
+				Node: &v1alpha1.NodeResult{
+					Phase: v1alpha1.NodePhase("Succeeded"),
+					Message: fmt.Sprintf("ArgoCD command succeeded: %s", namespace),
+				},
+			},
+		}
 
 		jsonResp, err := json.Marshal(resp)
 		if err != nil {

internal/argocd-plugin/plugin_test.go

@@ -2,64 +2,141 @@ package argocd
 
 import (
 	"bytes"
-	"encoding/json"
+	"errors"
+	"io"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 
 	"github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/common"
-	"github.com/argoproj/argo-workflows/v3/pkg/apis/workflow/v1alpha1"
-	"github.com/argoproj/argo-workflows/v3/pkg/plugins/executor"
 	"k8s.io/client-go/kubernetes/fake"
-	// "github.com/stretchr/testify/assert"
 )
 
 var (
-	workflow, _ = json.Marshal(json.RawMessage(`{"foo": "bar"}`))
+	headerEmpty				 			= map[string]string{}
+	headerContentJson 			= map[string]string{"Content-Type": "application/json"}
+	headerContentEncoded		= map[string]string{"Content-Type": "application/x-www-form-urlencoded"}
 )
+
+type errReader int
+
+func (errReader) Read(p []byte) (n int, err error) {
+    return 0, errors.New("Read error")
+}
+
 func TestArgocdPlugin(t *testing.T) {
-	var tests = []struct {
+	// test trying to invoke execute on argocd action
+	// test returning currect result based on input
+
+	kubeClient := fake.NewSimpleClientset()
+	argocdPlugin := ArgocdPlugin(kubeClient, "argo")
+	handler := http.HandlerFunc(argocdPlugin)
+
+	var failTests = []struct {
 		name string
-		request executor.ExecuteTemplateArgs
+		body io.Reader
+		headers map[string]string
 		want string
 		status int
 	}{
 		{
-			"parse body and return success", 
-			executor.ExecuteTemplateArgs{
-				Workflow: &executor.Workflow{
-					ObjectMeta: executor.ObjectMeta{Name: "workflow"},
-				},
-				Template: &v1alpha1.Template{
-					Name: "my-tmpl",
-					Plugin: &v1alpha1.Plugin{
-						Object: v1alpha1.Object{Value: json.RawMessage(
-							`{
-								"argocd": {}
-							}`)},	
-					},
-				},
-			},	
-			`{"node": { "phase": "Succeeded", "message": "Succeeded"}}`,
-			http.StatusOK,
+			name: "fail header content-type is empty",
+			body: nil,
+			headers: headerEmpty,
+			want: ErrWrongContentType.Error(),
+			status: http.StatusBadRequest,
+		},
+		{
+			name: "fail header content-type is not application/json",
+			body: nil,
+			headers: headerContentEncoded,
+			want: ErrWrongContentType.Error(),
+			status: http.StatusBadRequest,
+		},
+		{
+			name: "fail reading body",
+			body: errReader(0),
+			headers: headerContentJson,
+			want: ErrReadingBody.Error(),
+			status: http.StatusBadRequest,
+		},
+		{
+			name: "fail marshalling body",
+			body: bytes.NewReader([]byte(`"lol": "test"`)),
+			headers: headerContentJson,
+			want: ErrMarshallingBody.Error(),
+			status: http.StatusBadRequest,
+		},
+		{
+			name: "succeed marshalling body",
+			body: bytes.NewReader([]byte(`"lol": "test"`)),
+			headers: headerContentJson,
+			want: "Success",
+			status: http.StatusBadRequest,
 		},
 	}
 
-	kubeClient := fake.NewSimpleClientset()
-	argocdPlugin := ArgocdPlugin(kubeClient, "argo")
-	handler := http.HandlerFunc(argocdPlugin)
-
-	for _, tt := range tests {
+	for _, tt := range failTests {
 		t.Run(tt.name, func(t *testing.T) {
-			body, _ := json.Marshal(&tt.request)
-			request, _ := http.NewRequest(http.MethodPost, "/api/v1/template.execute", bytes.NewReader(body))
+			request, _ := http.NewRequest(http.MethodPost, "/api/v1/template.execute", tt.body)
+			for key, value := range tt.headers {
+				request.Header.Set(key, value)
+			}
 			response := httptest.NewRecorder()
-
 			handler.ServeHTTP(response, request)
-
 
-			common.AssertResponseBody(t, response.Body.String(), tt.want)
-			common.AssertStatus(t, response.Code, tt.status)
+			got := strings.Trim(response.Body.String(), "\n")
+			gotStatus := response.Code
+
+			common.AssertResponseBody(t, got, tt.want)
+			common.AssertStatus(t, gotStatus, tt.status)
 		})
 	}
+
 }
+
+// var tests = []struct {
+// 		name string
+// 		request executor.ExecuteTemplateArgs
+// 		want string
+// 		status int
+// 	}{
+// 		{
+// 			"parse body and return success", 
+// 			executor.ExecuteTemplateArgs{
+// 				Workflow: &executor.Workflow{
+// 					ObjectMeta: executor.ObjectMeta{Name: "workflow"},
+// 				},
+// 				Template: &v1alpha1.Template{
+// 					Name: "my-tmpl",
+// 					Plugin: &v1alpha1.Plugin{
+// 						Object: v1alpha1.Object{Value: json.RawMessage(
+// 							`{
+// 								"argocd": {}
+// 							}`)},	
+// 					},
+// 				},
+// 			},	
+// 			`{"node": { "phase": "Succeeded", "message": "Succeeded"}}`,
+// 			http.StatusOK,
+// 		},
+// 	}
+
+// 	kubeClient := fake.NewSimpleClientset()
+// 	argocdPlugin := ArgocdPlugin(kubeClient, "argo")
+// 	handler := http.HandlerFunc(argocdPlugin)
+
+// 	for _, tt := range tests {
+// 		t.Run(tt.name, func(t *testing.T) {
+// 			body, _ := json.Marshal(&tt.request)
+// 			request, _ := http.NewRequest(http.MethodPost, "/api/v1/template.execute", bytes.NewReader(body))
+// 			response := httptest.NewRecorder()
+
+// 			handler.ServeHTTP(response, request)
+
+			
+// 			common.AssertResponseBody(t, response.Body.String(), tt.want)
+// 			common.AssertStatus(t, response.Code, tt.status)
+// 		})
+// 	}