Adds middleware with overridable options

CHANGELOG.md

@@ -11,6 +11,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+## [1.2.0] - 2024-01-22
+
+### Added
+
+- Added support to override default middleware with function `GetDefaultMiddlewaresWithOptions`.
+
 ## [1.1.1] - 2023-11-22
 
 ### Added

kiota_client_factory.go

@@ -3,6 +3,8 @@
 package nethttplibrary
 
 import (
+	"errors"
+	abs "github.com/microsoft/kiota-abstractions-go"
 	nethttp "net/http"
 	"net/url"
 	"time"
@@ -76,12 +78,76 @@ func getDefaultClientWithoutMiddleware() *nethttp.Client {
 
 // GetDefaultMiddlewares creates a new default set of middlewares for the Kiota request adapter
 func GetDefaultMiddlewares() []Middleware {
-	return []Middleware{
-		NewRetryHandler(),
-		NewRedirectHandler(),
-		NewCompressionHandler(),
-		NewParametersNameDecodingHandler(),
-		NewUserAgentHandler(),
-		NewHeadersInspectionHandler(),
+	return getDefaultMiddleWare(make(map[string]Middleware))
+}
+
+// GetDefaultMiddlewaresWithOptions creates a new default set of middlewares for the Kiota request adapter with options
+func GetDefaultMiddlewaresWithOptions(requestOptions ...abs.RequestOption) ([]Middleware, error) {
+	if len(requestOptions) == 0 {
+		return GetDefaultMiddlewares(), nil
+	}
+
+	// map of middleware options
+	middlewareMap := make(map[string]Middleware)
+
+	for _, element := range requestOptions {
+		switch v := element.(type) {
+		case *RetryHandlerOptions:
+			middlewareMap["RetryHandler"] = NewRetryHandlerWithOptions(*v)
+		case *RedirectHandlerOptions:
+			middlewareMap["RedirectHandler"] = NewRedirectHandlerWithOptions(*v)
+		case *CompressionOptions:
+			middlewareMap["CompressionHandler"] = NewCompressionHandlerWithOptions(*v)
+		case *ParametersNameDecodingOptions:
+			middlewareMap["ParametersNameDecodingHandler"] = NewParametersNameDecodingHandlerWithOptions(*v)
+		case *UserAgentHandlerOptions:
+			middlewareMap["UserAgentHandler"] = NewUserAgentHandlerWithOptions(v)
+		case *HeadersInspectionOptions:
+			middlewareMap["HeadersInspectionHandler"] = NewHeadersInspectionHandlerWithOptions(*v)
+		default:
+			// none of the above types
+			return nil, errors.New("unsupported option type")
+		}
+	}
+
+	middleware := getDefaultMiddleWare(middlewareMap)
+	return middleware, nil
+}
+
+// getDefaultMiddleWare creates a new default set of middlewares for the Kiota request adapter
+func getDefaultMiddleWare(middlewareMap map[string]Middleware) []Middleware {
+	middlewareSource := map[string]func() Middleware{
+		"RetryHandler": func() Middleware {
+			return NewRetryHandler()
+		},
+		"RedirectHandler": func() Middleware {
+			return NewRedirectHandler()
+		},
+		"CompressionHandler": func() Middleware {
+			return NewCompressionHandler()
+		},
+		"ParametersNameDecodingHandler": func() Middleware {
+			return NewParametersNameDecodingHandler()
+		},
+		"UserAgentHandler": func() Middleware {
+			return NewUserAgentHandler()
+		},
+		"HeadersInspectionHandler": func() Middleware {
+			return NewHeadersInspectionHandler()
+		},
 	}
+
+	// loop over middlewareSource and add any middleware that wasn't provided in the requestOptions
+	for key, value := range middlewareSource {
+		if _, ok := middlewareMap[key]; !ok {
+			middlewareMap[key] = value()
+		}
+	}
+
+	var middleware []Middleware
+	for _, value := range middlewareMap {
+		middleware = append(middleware, value)
+	}
+
+	return middleware
 }

kiota_client_factory_test.go

@@ -0,0 +1,38 @@
+package nethttplibrary
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestGetDefaultMiddleWareWithOptions(t *testing.T) {
+	compression := NewCompressionOptions(false)
+	options, err := GetDefaultMiddlewaresWithOptions(&compression)
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+	if len(options) != 6 {
+		t.Errorf("expected 6 middleware, got %v", len(options))
+	}
+
+	for _, element := range options {
+		switch v := element.(type) {
+		case *CompressionHandler:
+			assert.Equal(t, v.options.ShouldCompress(), compression.ShouldCompress())
+		}
+	}
+}
+
+func TestGetDefaultMiddlewares(t *testing.T) {
+	options := GetDefaultMiddlewares()
+	if len(options) != 6 {
+		t.Errorf("expected 6 middleware, got %v", len(options))
+	}
+
+	for _, element := range options {
+		switch v := element.(type) {
+		case *CompressionHandler:
+			assert.True(t, v.options.ShouldCompress())
+		}
+	}
+}