lib/http: refactor of RegisterEndpoint and RegisterSSE to non-pointer

Once the endpoint registered, the caller should not able to changes
any values on endpoint again.

7 files changed, 33 insertions, 30 deletions

diff --git a/lib/http/endpoint_example_test.go b/lib/http/endpoint_example_test.go
index 2ca02de3..3549f488 100644
--- a/lib/http/endpoint_example_test.go
+++ b/lib/http/endpoint_example_test.go
@@ -21,7 +21,7 @@ func ExampleEndpoint_errorHandler() {
 	}
 	server, _ := NewServer(serverOpts)
 
-	endpointError := &Endpoint{
+	var endpointError = Endpoint{
 		Method:       RequestMethodGet,
 		Path:         "/",
 		RequestType:  RequestTypeQuery,
diff --git a/lib/http/endpoint_response_example_test.go b/lib/http/endpoint_response_example_test.go
index e9944edb..40e9d6d7 100644
--- a/lib/http/endpoint_response_example_test.go
+++ b/lib/http/endpoint_response_example_test.go
@@ -30,7 +30,7 @@ func ExampleEndpointResponse() {
 	// myData as JSON format.
 	// If the parameter "id" is missing or empty it will return an HTTP
 	// status code with message as defined in EndpointResponse.
-	err = server.RegisterEndpoint(&Endpoint{
+	err = server.RegisterEndpoint(Endpoint{
 		Method:       RequestMethodGet,
 		RequestType:  RequestTypeQuery,
 		ResponseType: ResponseTypeJSON,
diff --git a/lib/http/http_test.go b/lib/http/http_test.go
index 21e22216..c26746e3 100644
--- a/lib/http/http_test.go
+++ b/lib/http/http_test.go
@@ -137,7 +137,7 @@ func registerEndpoints() {
 	}
 
 	// Endpoint to test the client Download().
-	err = testServer.RegisterEndpoint(&Endpoint{
+	err = testServer.RegisterEndpoint(Endpoint{
 		Path:         "/download",
 		ResponseType: ResponseTypePlain,
 		Call: func(_ *EndpointRequest) ([]byte, error) {
@@ -149,7 +149,7 @@ func registerEndpoints() {
 	}
 
 	// Endpoint to test the client Download() with HTTP 302 redirect.
-	err = testServer.RegisterEndpoint(&Endpoint{
+	err = testServer.RegisterEndpoint(Endpoint{
 		Path:         "/redirect/download",
 		ResponseType: ResponseTypePlain,
 		Call: func(epr *EndpointRequest) ([]byte, error) {
diff --git a/lib/http/server.go b/lib/http/server.go
index e26fe082..d2e69ecc 100644
--- a/lib/http/server.go
+++ b/lib/http/server.go
@@ -95,42 +95,43 @@ func (srv *Server) RedirectTemp(res http.ResponseWriter, redirectURL string) {
 //
 // Endpoint with Method CONNECT or TRACE will return an error because its
 // not supported, yet.
-func (srv *Server) RegisterEndpoint(ep *Endpoint) (err error) {
-	if ep == nil {
-		return nil
-	}
+func (srv *Server) RegisterEndpoint(ep Endpoint) (err error) {
+	var logp = `RegisterEndpoint`
+
 	if ep.Call == nil {
-		return errors.New(`http.RegisterEndpoint: empty Call field`)
+		return errors.New(logp + `: empty Call field`)
 	}
 
 	switch ep.Method {
 	case RequestMethodConnect:
-		return errors.New(`http.RegisterEndpoint: can't handle CONNECT method yet`)
+		return errors.New(logp + `: can't handle CONNECT method yet`)
 	case RequestMethodDelete:
-		err = srv.registerDelete(ep)
+		err = srv.registerDelete(&ep)
 	case RequestMethodHead:
 		return nil
 	case RequestMethodOptions:
 		return nil
 	case RequestMethodPatch:
-		err = srv.registerPatch(ep)
+		err = srv.registerPatch(&ep)
 	case RequestMethodPost:
-		err = srv.registerPost(ep)
+		err = srv.registerPost(&ep)
 	case RequestMethodPut:
-		err = srv.registerPut(ep)
+		err = srv.registerPut(&ep)
 	case RequestMethodTrace:
-		return errors.New(`http.RegisterEndpoint: can't handle TRACE method yet`)
+		return errors.New(logp + `: can't handle TRACE method yet`)
 	case RequestMethodGet:
-		ep.Method = RequestMethodGet
-		err = srv.registerGet(ep)
+		err = srv.registerGet(&ep)
 	}
-	return err
+	if err != nil {
+		return fmt.Errorf(`%s: %w`, logp, err)
+	}
+	return nil
 }
 
 // RegisterSSE register Server-Sent Events endpoint.
 // It will return an error if the [SSEEndpoint.Call] field is not set or
 // [ErrEndpointAmbiguous] if the same path is already registered.
-func (srv *Server) RegisterSSE(ep *SSEEndpoint) (err error) {
+func (srv *Server) RegisterSSE(ep SSEEndpoint) (err error) {
 	var logp = `RegisterSSE`
 
 	if ep.Call == nil {
@@ -149,7 +150,7 @@ func (srv *Server) RegisterSSE(ep *SSEEndpoint) (err error) {
 		}
 	}
 
-	rute, err = newRouteSSE(ep)
+	rute, err = newRouteSSE(&ep)
 	if err != nil {
 		return err
 	}
@@ -190,6 +191,7 @@ func (srv *Server) RegisterEvaluator(eval Evaluator) {
 
 // registerGet register HTTP method GET with callback to handle it.
 func (srv *Server) registerGet(ep *Endpoint) (err error) {
+	ep.Method = RequestMethodGet
 	ep.RequestType = RequestTypeQuery
 
 	// Check if the same route already registered.
diff --git a/lib/http/server_test.go b/lib/http/server_test.go
index eee0144c..f18b27c6 100644
--- a/lib/http/server_test.go
+++ b/lib/http/server_test.go
@@ -49,7 +49,7 @@ func TestRegisterDelete(t *testing.T) {
 			ResponseType: ResponseTypePlain,
 			Call:         cbPlain,
 		},
-		expError: ErrEndpointAmbiguous.Error(),
+		expError: `RegisterEndpoint: ` + ErrEndpointAmbiguous.Error(),
 	}, {
 		desc:          "With unknown path",
 		reqURL:        testServerURL,
@@ -133,15 +133,16 @@ func TestRegisterDelete(t *testing.T) {
 		expBody:        "map[id:[1]]\nmap[]\n<nil>\n",
 	}}
 
+	var err error
 	for _, c := range cases {
 		t.Log(c.desc)
 
-		var err = testServer.RegisterEndpoint(c.ep)
-		if err != nil {
-			if !errors.Is(ErrEndpointAmbiguous, err) {
-				test.Assert(t, "error", c.expError, err.Error())
+		if c.ep != nil {
+			err = testServer.RegisterEndpoint(*c.ep)
+			if err != nil {
+				test.Assert(t, `error`, c.expError, err.Error())
+				continue
 			}
-			continue
 		}
 
 		if len(c.reqURL) == 0 {
diff --git a/lib/http/sse_endpoint_test.go b/lib/http/sse_endpoint_test.go
index c573af81..2a9e28f2 100644
--- a/lib/http/sse_endpoint_test.go
+++ b/lib/http/sse_endpoint_test.go
@@ -34,7 +34,7 @@ func TestSSEEndpoint(t *testing.T) {
 }
 
 func testSSEEndpointEmptyCall(t *testing.T, httpd *Server) {
-	var sse = &SSEEndpoint{
+	var sse = SSEEndpoint{
 		Path: `/sse`,
 	}
 
@@ -44,7 +44,7 @@ func testSSEEndpointEmptyCall(t *testing.T, httpd *Server) {
 }
 
 func testSSEEndpointDuplicatePath(t *testing.T, httpd *Server) {
-	var ep = &Endpoint{
+	var ep = Endpoint{
 		Path: `/sse`,
 		Call: func(_ *EndpointRequest) ([]byte, error) { return nil, nil },
 	}
@@ -54,7 +54,7 @@ func testSSEEndpointDuplicatePath(t *testing.T, httpd *Server) {
 		t.Fatal(err)
 	}
 
-	var sse = &SSEEndpoint{
+	var sse = SSEEndpoint{
 		Path: `/sse`,
 		Call: func(_ *SSEConn) {},
 	}
diff --git a/lib/http/sseclient/sseclient_test.go b/lib/http/sseclient/sseclient_test.go
index 84277311..d1ed4e1f 100644
--- a/lib/http/sseclient/sseclient_test.go
+++ b/lib/http/sseclient/sseclient_test.go
@@ -432,7 +432,7 @@ func testRunSSEServer(t *testing.T, cb libhttp.SSECallback) (srv *libhttp.Server
 		return nil, err
 	}
 
-	var sse = &libhttp.SSEEndpoint{
+	var sse = libhttp.SSEEndpoint{
 		Path: `/sse`,
 		Call: cb,
 	}