Feature/73 http command extractor

Author: Jan-Paul Konijn

test/utils/http/http_test.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"testing"
 
+	b64 "encoding/base64"
 	"soarca/models/cacao"
 	http "soarca/utils/http"
 
@@ -36,11 +37,15 @@ func TestHttpGetConnection(t *testing.T) {
 	httpRequest := http.HttpRequest{}
 
 	target := cacao.AgentTarget{HttpUrl: "https://httpbin.org/get"}
-	httpOptions := http.HttpOptions{
-		Method:  "GET",
-		Target:  target,
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "GET / HTTP/1.1",
 		Headers: map[string]string{"accept": "application/json"},
 	}
+	httpOptions := http.HttpOptions{
+		Command: &command,
+		Target:  &target,
+	}
 	response, err := httpRequest.Request(httpOptions)
 	t.Log(string(response))
 	if err != nil {
@@ -56,11 +61,15 @@ func TestHttpPostConnection(t *testing.T) {
 	httpRequest := http.HttpRequest{}
 
 	target := cacao.AgentTarget{HttpUrl: "https://httpbin.org/post"}
-	httpOptions := http.HttpOptions{
-		Method:  "POST",
-		Target:  target,
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST / HTTP/1.1",
 		Headers: map[string]string{"accept": "application/json"},
 	}
+	httpOptions := http.HttpOptions{
+		Command: &command,
+		Target:  &target,
+	}
 	response, err := httpRequest.Request(httpOptions)
 	t.Log(string(response))
 	if err != nil {
@@ -75,11 +84,15 @@ func TestHttpPostConnection(t *testing.T) {
 func TestHttpPutConnection(t *testing.T) {
 	httpRequest := http.HttpRequest{}
 	target := cacao.AgentTarget{HttpUrl: "https://httpbin.org/put"}
-	httpOptions := http.HttpOptions{
-		Method:  "PUT",
-		Target:  target,
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "PUT / HTTP/1.1",
 		Headers: map[string]string{"accept": "application/json"},
 	}
+	httpOptions := http.HttpOptions{
+		Command: &command,
+		Target:  &target,
+	}
 	response, err := httpRequest.Request(httpOptions)
 	if err != nil {
 		t.Fatalf(fmt.Sprint("http put request test has failed: ", err))
@@ -93,11 +106,15 @@ func TestHttpPutConnection(t *testing.T) {
 func TestHttpDeleteConnection(t *testing.T) {
 	httpRequest := http.HttpRequest{}
 	target := cacao.AgentTarget{HttpUrl: "https://httpbin.org/delete"}
-	httpOptions := http.HttpOptions{
-		Method:  "DELETE",
-		Target:  target,
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "DELETE / HTTP/1.1",
 		Headers: map[string]string{"accept": "application/json"},
 	}
+	httpOptions := http.HttpOptions{
+		Command: &command,
+		Target:  &target,
+	}
 	response, err := httpRequest.Request(httpOptions)
 	if err != nil {
 		t.Fatalf(fmt.Sprint("http delete request test has failed: ", err))
@@ -113,11 +130,15 @@ func TestHttpDeleteConnection(t *testing.T) {
 func TestHttpStatus200(t *testing.T) {
 	httpRequest := http.HttpRequest{}
 	target := cacao.AgentTarget{HttpUrl: "https://httpbin.org/status/200"}
-	httpOptions := http.HttpOptions{
-		Method:  "GET",
-		Target:  target,
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "GET / HTTP/1.1",
 		Headers: map[string]string{"accept": "application/json"},
 	}
+	httpOptions := http.HttpOptions{
+		Command: &command,
+		Target:  &target,
+	}
 	// error codes are handled internally by request, with throw error != in 200 range
 	_, err := httpRequest.Request(httpOptions)
 	t.Log(err)
@@ -131,10 +152,14 @@ func TestHttpBearerToken(t *testing.T) {
 	bearerToken := "test"
 	httpRequest := http.HttpRequest{}
 	target := cacao.AgentTarget{HttpUrl: "https://httpbin.org/bearer"}
-	httpOptions := http.HttpOptions{
-		Method:  "GET",
-		Target:  target,
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "GET / HTTP/1.1",
 		Headers: map[string]string{"accept": "application/json"},
+	}
+	httpOptions := http.HttpOptions{
+		Command: &command,
+		Target:  &target,
 		Token:   bearerToken,
 	}
 	response, err := httpRequest.Request(httpOptions)
@@ -163,11 +188,14 @@ func TestHttpBasicAuth(t *testing.T) {
 	httpRequest := http.HttpRequest{}
 
 	target := cacao.AgentTarget{HttpUrl: url}
-
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "GET / HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
 	httpOptions := http.HttpOptions{
-		Method:   "GET",
-		Target:   target,
-		Headers:  map[string]string{"accept": "application/json"},
+		Command:  &command,
+		Target:   &target,
 		Username: username,
 		Password: password,
 	}
@@ -195,18 +223,23 @@ func TestHttpPostWithContentConnection(t *testing.T) {
 
 	testJsonObj := testJson{Id: "28818819", User: "test", Description: "very interesting description"}
 	requestBody, err := json.Marshal(testJsonObj)
+	base64EncodedBody := b64.StdEncoding.EncodeToString(requestBody)
 	if err != nil {
 		fmt.Println("error Marshall JSON:", err)
 	}
 	if len(requestBody) == 0 {
 		t.Fatalf("empty response")
 	}
 	target := cacao.AgentTarget{HttpUrl: "https://httpbin.org/anything"}
+	command := cacao.Command{
+		Type:       "http-api",
+		Command:    "POST / HTTP/1.1",
+		Headers:    map[string]string{"accept": "application/json"},
+		ContentB64: base64EncodedBody,
+	}
 	httpOptions := http.HttpOptions{
-		Method:  "POST",
-		Target:  target,
-		Headers: map[string]string{"accept": "application/json"},
-		Body:    requestBody,
+		Command: &command,
+		Target:  &target,
 	}
 	response, err := httpRequest.Request(httpOptions)
 
@@ -215,30 +248,32 @@ func TestHttpPostWithContentConnection(t *testing.T) {
 		t.Fatalf(fmt.Sprint("http post request with body content has failed: ", err))
 	}
 
+	// specific format used by httpbin.org
 	var httpBinReponse httpBinResponseBody
 	err = json.Unmarshal(response, &httpBinReponse)
+	fmt.Println(httpBinReponse)
 	if err != nil {
-		fmt.Println("Error decoding JSON:", err)
 		t.Fatalf(fmt.Sprint("Could not unmashall reponse token for bearer test,", err))
 	}
-
-	var responseToken bearerResponse
-	err = json.Unmarshal([]byte(httpBinReponse.Data), &responseToken)
-	if err != nil {
-		fmt.Println("Error decoding JSON:", err)
-		t.Fatalf(fmt.Sprint("Could not unmashall reponse token for bearer test,", err))
-	}
-	assert.Equal(t, testJsonObj.Id, "28818819")
-	assert.Equal(t, testJsonObj.User, "test")
-	assert.Equal(t, testJsonObj.Description, "very interesting description")
+	assert.Equal(t, httpBinReponse.Data, base64EncodedBody)
 }
 
 func TestHttpPathDnameParser(t *testing.T) {
 	addresses := make(map[string][]string, 1)
 	addresses["dname"] = []string{"soarca.tno.nl"}
 
-	testTarget := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(80)}
-	parsedUrl, err := http.ExtractUrl(testTarget, "/url")
+	target := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(80)}
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST /url HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	httpOptions := http.HttpOptions{
+		Target:  &target,
+		Command: &command,
+	}
+
+	parsedUrl, err := httpOptions.ExtractUrl()
 	if err != nil {
 		t.Fatalf(fmt.Sprint("failed test because: ", err))
 	}
@@ -249,8 +284,18 @@ func TestHttpPathDnamePortParser(t *testing.T) {
 	addresses := make(map[string][]string, 1)
 	addresses["dname"] = []string{"soarca.tno.nl"}
 
-	testTarget := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(8080)}
-	parsedUrl, err := http.ExtractUrl(testTarget, "/url")
+	target := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(8080)}
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST /url HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	httpOptions := http.HttpOptions{
+		Target:  &target,
+		Command: &command,
+	}
+
+	parsedUrl, err := httpOptions.ExtractUrl()
 	if err != nil {
 		t.Fatalf(fmt.Sprint("failed test because: ", err))
 	}
@@ -259,10 +304,20 @@ func TestHttpPathDnamePortParser(t *testing.T) {
 
 func TestHttpPathDnameRandomPortParser(t *testing.T) {
 	addresses := make(map[string][]string, 1)
-	addresses["dname"] = []string{"soarca.tno.nl"}
+	addresses["dname"] = []string{"http://soarca.tno.nl"}
+
+	target := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(6464)}
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST /url HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	httpOptions := http.HttpOptions{
+		Target:  &target,
+		Command: &command,
+	}
 
-	testTarget := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(6464)}
-	parsedUrl, err := http.ExtractUrl(testTarget, "/url")
+	parsedUrl, err := httpOptions.ExtractUrl()
 	if err != nil {
 		t.Fatalf(fmt.Sprint("failed test because: ", err))
 	}
@@ -273,28 +328,110 @@ func TestHttpPathIpv4Parser(t *testing.T) {
 	addresses := make(map[string][]string, 1)
 	addresses["ipv4"] = []string{"127.0.0.1"}
 
-	testTarget := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(443)}
-	parsedUrl, err := http.ExtractUrl(testTarget, "")
+	target := cacao.AgentTarget{Address: addresses, Port: strconv.Itoa(443)}
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST / HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	httpOptions := http.HttpOptions{
+		Target:  &target,
+		Command: &command,
+	}
+
+	parsedUrl, err := httpOptions.ExtractUrl()
 	if err != nil {
 		t.Fatalf(fmt.Sprint("failed test because: ", err))
 	}
-	assert.Equal(t, parsedUrl, "https://127.0.0.1:443")
+	assert.Equal(t, parsedUrl, "https://127.0.0.1:443/")
 }
 
 func TestHttpPathParser(t *testing.T) {
-	testTarget := cacao.AgentTarget{HttpUrl: "https://godcapability.tno.nl"}
-	parsedUrl, err := http.ExtractUrl(testTarget, "")
+	target := cacao.AgentTarget{HttpUrl: "https://godcapability.tno.nl"}
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST / HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	httpOptions := http.HttpOptions{
+		Target:  &target,
+		Command: &command,
+	}
+
+	parsedUrl, err := httpOptions.ExtractUrl()
 	if err != nil {
 		t.Fatalf(fmt.Sprint("failed test because: ", err))
 	}
 	assert.Equal(t, parsedUrl, "https://godcapability.tno.nl")
 }
 
 func TestHttpPathBreakingParser(t *testing.T) {
-	testTarget := cacao.AgentTarget{HttpUrl: "https://"}
-	parsedUrl, err := http.ExtractUrl(testTarget, "")
+	target := cacao.AgentTarget{HttpUrl: "https://"}
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST / HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	httpOptions := http.HttpOptions{
+		Target:  &target,
+		Command: &command,
+	}
+
+	parsedUrl, err := httpOptions.ExtractUrl()
 	if err == nil {
 		t.Error("want error for invalid empty domainname")
 	}
 	t.Logf(fmt.Sprint(parsedUrl))
 }
+
+func TestMethodExtract(t *testing.T) {
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST /api1/newObject HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	method, err := http.GetMethodFrom(&command)
+	if err != nil {
+		t.Fatalf(fmt.Sprint("failed test because: ", err))
+	}
+	assert.Equal(t, method, "POST")
+}
+
+func TestPathExtract(t *testing.T) {
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST /api1/newObject HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	path, err := http.GetPathFrom(&command)
+	if err != nil {
+		t.Fatalf(fmt.Sprint("failed test because: ", err))
+	}
+	assert.Equal(t, path, "/api1/newObject")
+}
+
+func TestVersionExtract(t *testing.T) {
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST /api1/newObject HTTP/1.1",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	version, err := http.GetVersionFrom(&command)
+	if err != nil {
+		t.Fatalf(fmt.Sprint("failed test because: ", err))
+	}
+	assert.Equal(t, version, "HTTP/1.1")
+}
+
+func TestCommandFailedExtract(t *testing.T) {
+	command := cacao.Command{
+		Type:    "http-api",
+		Command: "POST /api1/newObject",
+		Headers: map[string]string{"accept": "application/json"},
+	}
+	version, err := http.GetVersionFrom(&command)
+	if err == nil {
+		t.Error("should give error as only 2 values are provided")
+	}
+	assert.Equal(t, version, "")
+}