完成invoke测试

test/invoke_test.go

@@ -0,0 +1,466 @@
+package test
+
+import (
+	"context"
+	"fmt"
+	"git.sxidc.com/service-supports/dapr_api/invoke"
+	"github.com/stretchr/testify/assert"
+	"io"
+	"net/http"
+	"sync"
+	"testing"
+	"time"
+)
+
+const (
+	invokeServerAddress = "localhost:10081"
+
+	baseUrl     = "http://localhost:10081"
+	daprBaseUrl = "http://localhost:10080/v1.0/invoke/dapr_api/method"
+
+	postJsonMethodName   = "/post-json"
+	deleteJsonMethodName = "/delete-json"
+	putJsonMethodName    = "/put-json"
+	getJsonMethodName    = "/get-json"
+	postMethodName       = "/post"
+	deleteMethodName     = "/delete"
+	putMethodName        = "/put"
+	getMethodName        = "/get"
+
+	postJsonData = `"{"data":"post-json"}"`
+	postData     = `post`
+	putJsonData  = `"{"data":"put-json"}"`
+	putData      = `put`
+
+	postJsonResponse   = `"{"data":"response-post-json"}"`
+	postResponse       = `response-post`
+	deleteJsonResponse = `"{"data":"response-delete-json"}"`
+	deleteResponse     = `response-delete`
+	putJsonResponse    = `"{"data":"response-put-json"}"`
+	putResponse        = `response-put`
+	getJsonResponse    = `"{"data":"response-get-json"}"`
+	getResponse        = `response-get`
+)
+
+func TestPostJSON(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.PostJSON(postJsonMethodName, []byte(postJsonData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, postJsonResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.PostJSON(postJsonMethodName, []byte(postJsonData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, postJsonResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func TestDeleteJSON(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.DeleteJSON(deleteJsonMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, deleteJsonResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.DeleteJSON(deleteJsonMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, deleteJsonResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func TestPutJSON(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.PutJSON(putJsonMethodName, []byte(putJsonData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, putJsonResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.PutJSON(putJsonMethodName, []byte(putJsonData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, putJsonResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func TestGetJSON(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.GetJSON(getJsonMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, getJsonResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.GetJSON(getJsonMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, getJsonResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func TestPost(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.PostJSON(postMethodName, []byte(postData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, postResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.PostJSON(postMethodName, []byte(postData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, postResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func TestDelete(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.DeleteJSON(deleteMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, deleteResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.DeleteJSON(deleteMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, deleteResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func TestPut(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.PutJSON(putMethodName, []byte(putData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, putResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.PutJSON(putMethodName, []byte(putData))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, putResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func TestGet(t *testing.T) {
+	api := invoke.NewAPI(baseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(api)
+
+	daprAPI := invoke.NewAPI(daprBaseUrl, 10*time.Second)
+	defer invoke.DestroyAPI(daprAPI)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initInvokeHttpServer(t, wgServer, wg)
+	wgServer.Wait()
+
+	response, err := api.GetJSON(getMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, getResponse, string(response), "响应不一致")
+
+	daprResponse, err := daprAPI.GetJSON(getMethodName)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert.Equal(t, getResponse, string(daprResponse), "响应不一致")
+
+	wg.Wait()
+
+	_ = srv.Shutdown(context.Background())
+}
+
+func initInvokeHttpServer(t *testing.T, wgServer *sync.WaitGroup, wg *sync.WaitGroup) *http.Server {
+	mux := http.NewServeMux()
+
+	mux.HandleFunc("/post-json", func(w http.ResponseWriter, r *http.Request) {
+		request, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if string(request) != postJsonData {
+			t.Fatal(err)
+		}
+
+		fmt.Println("post-json Receive:", string(request))
+
+		w.WriteHeader(http.StatusOK)
+		_, err = w.Write([]byte(postJsonResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	mux.HandleFunc("/delete-json", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Println("delete-json")
+
+		w.WriteHeader(http.StatusOK)
+		_, err := w.Write([]byte(deleteJsonResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	mux.HandleFunc("/put-json", func(w http.ResponseWriter, r *http.Request) {
+		request, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if string(request) != putJsonData {
+			t.Fatal(err)
+		}
+
+		fmt.Println("put-json Receive:", string(request))
+
+		w.WriteHeader(http.StatusOK)
+		_, err = w.Write([]byte(putJsonResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	mux.HandleFunc("/get-json", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Println("get-json")
+
+		w.WriteHeader(http.StatusOK)
+		_, err := w.Write([]byte(getJsonResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	mux.HandleFunc("/post", func(w http.ResponseWriter, r *http.Request) {
+		request, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if string(request) != postData {
+			t.Fatal(err)
+		}
+
+		fmt.Println("post Receive:", string(request))
+
+		w.WriteHeader(http.StatusOK)
+		_, err = w.Write([]byte(postResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	mux.HandleFunc("/delete", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Println("delete")
+
+		w.WriteHeader(http.StatusOK)
+		_, err := w.Write([]byte(deleteResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	mux.HandleFunc("/put", func(w http.ResponseWriter, r *http.Request) {
+		request, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if string(request) != putData {
+			t.Fatal(err)
+		}
+
+		fmt.Println("put Receive:", string(request))
+
+		w.WriteHeader(http.StatusOK)
+		_, err = w.Write([]byte(putResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	mux.HandleFunc("/get", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Println("get")
+
+		w.WriteHeader(http.StatusOK)
+		_, err := w.Write([]byte(getResponse))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+	})
+
+	srv := &http.Server{
+		Addr:    invokeServerAddress,
+		Handler: mux,
+	}
+
+	go func() {
+		wgServer.Done()
+		err := srv.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			panic(err)
+		}
+	}()
+
+	return srv
+}

test/pubsub_test.go

@@ -8,12 +8,14 @@ import (
 	"git.sxidc.com/service-supports/dapr_api/utils"
 	"io"
 	"net/http"
+	"sync"
 	"testing"
 	"time"
 )
 
 const (
-	serverAddress       = "localhost:10081"
+	pubSubServerAddress = "localhost:10081"
+
 	sendMessageMaxCount = 3
 	pubsubName          = "dapr_pubsub"
 	topic               = "test_pubsub"
@@ -25,7 +27,10 @@ func TestPubSub(t *testing.T) {
 
 	sendMessageCount := 0
 
-	srv := initHttpServer(&sendMessageCount)
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initPubSubHttpServer(wgServer, &sendMessageCount)
+	wgServer.Wait()
 
 	go func() {
 		for sendMessageCount < sendMessageMaxCount {
@@ -58,7 +63,10 @@ func TestPubSubJson(t *testing.T) {
 
 	sendMessageCount := 0
 
-	srv := initHttpServer(&sendMessageCount)
+	wgServer := &sync.WaitGroup{}
+	wgServer.Add(1)
+	srv := initPubSubHttpServer(wgServer, &sendMessageCount)
+	wgServer.Wait()
 
 	go func() {
 		for sendMessageCount < sendMessageMaxCount {
@@ -85,7 +93,7 @@ func TestPubSubJson(t *testing.T) {
 	_ = srv.Shutdown(context.Background())
 }
 
-func initHttpServer(sendMessageCount *int) *http.Server {
+func initPubSubHttpServer(wg *sync.WaitGroup, sendMessageCount *int) *http.Server {
 	mux := http.NewServeMux()
 	mux.HandleFunc("/test_pubsub", func(w http.ResponseWriter, r *http.Request) {
 		body, err := io.ReadAll(r.Body)
@@ -102,11 +110,12 @@ func initHttpServer(sendMessageCount *int) *http.Server {
 	})
 
 	srv := &http.Server{
-		Addr:    serverAddress,
+		Addr:    pubSubServerAddress,
 		Handler: mux,
 	}
 
 	go func() {
+		wg.Done()
 		err := srv.ListenAndServe()
 		if err != nil && err != http.ErrServerClosed {
 			panic(err)