feat: add handler interface that handlers must implement (#74)

* feat: add handler interface that handlers must implement

* chore: lint

Author: tomMoulard

.golangci.yml

@@ -4,23 +4,10 @@ run:
 linters:
   enable-all: true
   disable:
-    - exhaustivestruct # deprecated
-    - interfacer # deprecated
-    - varcheck # deprecated
-    - nosnakecase # deprecated
-    - ifshort # deprecated
-    - maligned # deprecated
-    - deadcode # deprecated
-    - scopelint # deprecated
-    - structcheck # deprecated
-    - golint # deprecated
-    - rowserrcheck # deprecated
-    - sqlclosecheck # deprecated
-    - wastedassign # deprecated
+    - gomnd # deprecated
+    - execinquery # deprecated
     - varnamelen # useless
-    - paralleltest # false positive
-    - tparallel # false positive
-    - tagliatelle # Breaking: 'Rule' tag -> 'rule'
+    - ireturn # Not relevant
 
 issues:
   exclude-rules:
@@ -39,3 +26,8 @@ linters-settings:
         deny:
           - pkg: "github.com/instana/testify"
             desc: not allowed
+  tagliatelle:
+    case:
+      use-field-name: true
+      rules:
+        yaml: goPascal

htransformation.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"net/http"
-	"regexp"
 
 	"github.com/tomMoulard/htransformation/pkg/handler/deleter"
 	"github.com/tomMoulard/htransformation/pkg/handler/join"
@@ -16,10 +15,9 @@ import (
 
 // HeadersTransformation holds the necessary components of a Traefik plugin.
 type HeadersTransformation struct {
-	name         string
-	next         http.Handler
-	rules        []types.Rule
-	ruleHandlers map[types.RuleType]func(http.ResponseWriter, *http.Request, types.Rule)
+	name     string
+	next     http.Handler
+	handlers []types.Handler
 }
 
 // Config holds configuration to be passed to the plugin.
@@ -36,64 +34,46 @@ func CreateConfig() *Config {
 
 // New instantiates and returns the required components used to handle an HTTP request.
 func New(_ context.Context, next http.Handler, config *Config, name string) (http.Handler, error) {
-	ruleHandlers := map[types.RuleType]func(http.ResponseWriter, *http.Request, types.Rule){
-		types.Delete:           deleter.Handle,
-		types.Join:             join.Handle,
-		types.Rename:           rename.Handle,
-		types.RewriteValueRule: rewrite.Handle,
-		types.Set:              set.Handle,
+	handlerBuilder := map[types.RuleType]func(types.Rule) (types.Handler, error){
+		types.Delete:           deleter.New,
+		types.Join:             join.New,
+		types.Rename:           rename.New,
+		types.RewriteValueRule: rewrite.New,
+		types.Set:              set.New,
 	}
 
-	validateRules := map[types.RuleType]func(types.Rule) error{
-		types.Delete:           deleter.Validate,
-		types.Join:             join.Validate,
-		types.Rename:           rename.Validate,
-		types.RewriteValueRule: rewrite.Validate,
-		types.Set:              set.Validate,
-	}
+	handlers := make([]types.Handler, 0, len(config.Rules))
 
-	for i, rule := range config.Rules {
-		if _, ok := ruleHandlers[rule.Type]; !ok {
+	for _, rule := range config.Rules {
+		newHandler, ok := handlerBuilder[rule.Type]
+		if !ok {
 			return nil, fmt.Errorf("%w: %s", types.ErrInvalidRuleType, rule.Name)
 		}
 
-		validate, ok := validateRules[rule.Type]
-		if !ok {
-			continue
+		h, err := newHandler(rule)
+		if err != nil {
+			return nil, fmt.Errorf("%w: %s", err, rule.Name)
 		}
 
-		if err := validate(rule); err != nil {
+		if err := h.Validate(); err != nil {
 			return nil, fmt.Errorf("%w: %s", err, rule.Name)
 		}
 
-		if rule.Type == types.Rename || rule.Type == types.RewriteValueRule {
-			re, err := regexp.Compile(rule.Header)
-			if err != nil { // must be validated before
-				return nil, fmt.Errorf("%w: %s", types.ErrInvalidRegexp, rule.Name)
-			}
-
-			config.Rules[i].Regexp = re
-		}
+		handlers = append(handlers, h)
 	}
 
 	return &HeadersTransformation{
-		name:         name,
-		next:         next,
-		rules:        config.Rules,
-		ruleHandlers: ruleHandlers,
+		name:     name,
+		next:     next,
+		handlers: handlers,
 	}, nil
 }
 
 // Iterate over every header to match the ones specified in the config and
 // return nothing if regexp failed.
 func (u *HeadersTransformation) ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) {
-	for _, rule := range u.rules {
-		ruleHandler, ok := u.ruleHandlers[rule.Type]
-		if !ok {
-			continue
-		}
-
-		ruleHandler(responseWriter, request, rule)
+	for _, handler := range u.handlers {
+		handler.Handle(responseWriter, request)
 	}
 
 	u.next.ServeHTTP(responseWriter, request)

htransformation_test.go

@@ -13,6 +13,8 @@ import (
 )
 
 func TestValidation(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		name    string
 		config  *plug.Config
@@ -108,6 +110,8 @@ func TestValidation(t *testing.T) {
 }
 
 func TestHeaderRules(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		name             string
 		rule             types.Rule

pkg/handler/deleter/delete.go

@@ -7,16 +7,24 @@ import (
 	"github.com/tomMoulard/htransformation/pkg/utils/header"
 )
 
-func Validate(types.Rule) error {
+type Deleter struct {
+	rule *types.Rule
+}
+
+func New(rule types.Rule) (types.Handler, error) {
+	return &Deleter{rule: &rule}, nil
+}
+
+func (d *Deleter) Validate() error {
 	return nil
 }
 
-func Handle(rw http.ResponseWriter, req *http.Request, rule types.Rule) {
-	if rule.SetOnResponse {
-		rw.Header().Del(rule.Header)
+func (d *Deleter) Handle(rw http.ResponseWriter, req *http.Request) {
+	if d.rule.SetOnResponse {
+		rw.Header().Del(d.rule.Header)
 
 		return
 	}
 
-	header.Delete(req, rule.Header)
+	header.Delete(req, d.rule.Header)
 }

pkg/handler/deleter/delete_test.go

@@ -70,7 +70,10 @@ func TestDeleteHandler(t *testing.T) {
 				req.Header.Add(hName, hVal)
 			}
 
-			deleter.Handle(nil, req, test.rule)
+			deleteHandler, err := deleter.New(test.rule)
+			require.NoError(t, err)
+
+			deleteHandler.Handle(nil, req)
 
 			for hName, hVal := range test.expectedHeaders {
 				assert.Equal(t, hVal, req.Header.Get(hName))
@@ -130,7 +133,10 @@ func TestDeleteHandlerOnResponse(t *testing.T) {
 				rw.Header().Add(hName, hVal)
 			}
 
-			deleter.Handle(rw, nil, test.rule)
+			deleteHandler, err := deleter.New(test.rule)
+			require.NoError(t, err)
+
+			deleteHandler.Handle(rw, nil)
 
 			for hName, hVal := range test.want {
 				assert.Equal(t, hVal, rw.Header().Get(hName))
@@ -140,6 +146,8 @@ func TestDeleteHandlerOnResponse(t *testing.T) {
 }
 
 func TestValidation(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		name    string
 		rule    types.Rule
@@ -163,7 +171,10 @@ func TestValidation(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
 
-			err := deleter.Validate(test.rule)
+			deleteHandler, err := deleter.New(test.rule)
+			require.NoError(t, err)
+
+			err = deleteHandler.Validate()
 			t.Log(err)
 
 			if test.wantErr {

pkg/handler/join/join.go

@@ -7,42 +7,50 @@ import (
 	"github.com/tomMoulard/htransformation/pkg/types"
 )
 
-func Validate(rule types.Rule) error {
-	if len(rule.Values) == 0 || rule.Sep == "" {
+type Join struct {
+	rule *types.Rule
+}
+
+func New(rule types.Rule) (types.Handler, error) {
+	return &Join{rule: &rule}, nil
+}
+
+func (j *Join) Validate() error {
+	if len(j.rule.Values) == 0 || j.rule.Sep == "" {
 		return types.ErrMissingRequiredFields
 	}
 
 	return nil
 }
 
-func Handle(rw http.ResponseWriter, req *http.Request, rule types.Rule) {
+func (j *Join) Handle(rw http.ResponseWriter, req *http.Request) {
 	var val []string
-	if strings.EqualFold(rule.Header, "Host") {
+	if strings.EqualFold(j.rule.Header, "Host") {
 		val = []string{req.Host}
 	} else {
 		var ok bool
-		val, ok = req.Header[rule.Header]
+		val, ok = req.Header[j.rule.Header]
 
 		if !ok {
 			return
 		}
 	}
 
 	newHeaderVal := val[0]
-	for _, value := range rule.Values {
-		newHeaderVal += rule.Sep + getValue(value, rule.HeaderPrefix, req)
+	for _, value := range j.rule.Values {
+		newHeaderVal += j.rule.Sep + getValue(value, j.rule.HeaderPrefix, req)
 	}
 
-	if rule.SetOnResponse {
-		rw.Header().Set(rule.Name, newHeaderVal)
+	if j.rule.SetOnResponse {
+		rw.Header().Set(j.rule.Name, newHeaderVal)
 
 		return
 	}
 
-	if strings.EqualFold(rule.Header, "Host") {
+	if strings.EqualFold(j.rule.Header, "Host") {
 		req.Host = newHeaderVal
 	} else {
-		req.Header.Set(rule.Header, newHeaderVal)
+		req.Header.Set(j.rule.Header, newHeaderVal)
 	}
 }
 

pkg/handler/join/join_test.go

@@ -12,6 +12,8 @@ import (
 )
 
 func TestJoinHandler(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		name            string
 		rule            types.Rule
@@ -199,7 +201,10 @@ func TestJoinHandler(t *testing.T) {
 				req.Header.Add(hName, hVal)
 			}
 
-			join.Handle(nil, req, test.rule)
+			joinHandler, err := join.New(test.rule)
+			require.NoError(t, err)
+
+			joinHandler.Handle(nil, req)
 
 			for hName, hVal := range test.expectedHeaders {
 				assert.Equal(t, hVal, req.Header.Get(hName))
@@ -212,6 +217,8 @@ func TestJoinHandler(t *testing.T) {
 }
 
 func TestValidation(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		name    string
 		rule    types.Rule
@@ -262,7 +269,10 @@ func TestValidation(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
 
-			err := join.Validate(test.rule)
+			joinHandler, err := join.New(test.rule)
+			require.NoError(t, err)
+
+			err = joinHandler.Validate()
 			t.Log(err)
 
 			if test.wantErr {

pkg/handler/rename/rename.go

@@ -9,38 +9,49 @@ import (
 	"github.com/tomMoulard/htransformation/pkg/utils/header"
 )
 
-func Validate(rule types.Rule) error {
-	if _, err := regexp.Compile(rule.Header); err != nil {
-		return fmt.Errorf("%s: %w", types.ErrInvalidRegexp.Error(), err)
+type Rename struct {
+	rule *types.Rule
+}
+
+func New(rule types.Rule) (types.Handler, error) {
+	re, err := regexp.Compile(rule.Header)
+	if err != nil {
+		return nil, fmt.Errorf("%w: %s", types.ErrInvalidRegexp, rule.Name)
 	}
 
-	if rule.Value == "" {
+	rule.Regexp = re
+
+	return &Rename{rule: &rule}, nil
+}
+
+func (r *Rename) Validate() error {
+	if r.rule.Value == "" {
 		return types.ErrMissingRequiredFields
 	}
 
 	return nil
 }
 
-func Handle(rw http.ResponseWriter, req *http.Request, rule types.Rule) {
+func (r *Rename) Handle(rw http.ResponseWriter, req *http.Request) {
 	originalHost := req.Header.Get("Host") // Eventually X-Forwarded-Host
 	req.Header.Set("Host", req.Host)
 
 	for headerName, headerValues := range req.Header {
-		if matched := rule.Regexp.Match([]byte(headerName)); !matched {
+		if matched := r.rule.Regexp.Match([]byte(headerName)); !matched {
 			continue
 		}
 
-		if rule.SetOnResponse {
+		if r.rule.SetOnResponse {
 			rw.Header().Del(headerName)
 		} else {
 			header.Delete(req, headerName)
 		}
 
 		for _, val := range headerValues {
-			if rule.SetOnResponse {
-				rw.Header().Set(rule.Value, val)
+			if r.rule.SetOnResponse {
+				rw.Header().Set(r.rule.Value, val)
 			} else {
-				header.Set(req, rule.Value, val)
+				header.Set(req, r.rule.Value, val)
 			}
 		}
 	}