Add a new ConfigSetter that accepts a callback function that will intercept HTTP calls

okta/config.go

@@ -18,11 +18,13 @@ package okta
 
 import (
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
 	"syscall"
+	"time"
 
 	"github.com/okta/okta-sdk-golang/v2/okta/cache"
 	"gopkg.in/square/go-jose.v2"
@@ -69,6 +71,28 @@ type config struct {
 
 type ConfigSetter func(*config)
 
+type InterceptingRoundTripper struct {
+	Transport   http.RoundTripper
+	Interceptor func(*http.Request) error
+	Blocking    bool
+}
+
+func WithHttpInterceptorAndHttpClientPtr(interceptor func(*http.Request) error, httpClient *http.Client, blocking bool) ConfigSetter {
+	return func(c *config) {
+		if httpClient == nil {
+			httpClient = http.DefaultClient
+		}
+
+		if httpClient.Transport == nil {
+			httpClient.Transport = &http.Transport{
+				IdleConnTimeout: 30 * time.Second,
+			}
+		}
+
+		c.HttpClient.Transport = NewInterceptingRoundTripper(interceptor, httpClient.Transport, blocking)
+	}
+}
+
 func WithCache(cache bool) ConfigSetter {
 	return func(c *config) {
 		c.Okta.Client.Cache.Enabled = cache
@@ -240,3 +264,36 @@ func fileExists(filename string) bool {
 	}
 	return !info.IsDir()
 }
+
+func (c *InterceptingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	interceptError := func() (err error) {
+		defer func() {
+			if panicked := recover(); panicked != nil {
+				if panickedErrString, ok := panicked.(string); ok {
+					err = fmt.Errorf("recovered panic in Okta HTTP interceptor: %s", panickedErrString)
+				} else {
+					err = fmt.Errorf("recovered panic in Okta HTTP interceptor, but failed to parse error string")
+				}
+			}
+		}()
+		return c.Interceptor(req)
+	}()
+
+	if interceptError != nil && c.Blocking {
+		return nil, interceptError
+	}
+
+	if c.Transport != nil {
+		response, roundTripperErr := c.Transport.RoundTrip(req)
+		return response, roundTripperErr
+	}
+	return nil, fmt.Errorf("an error ocurred in Okta SDK, Transport was nil")
+}
+
+func NewInterceptingRoundTripper(interceptor func(*http.Request) error, transport http.RoundTripper, blocking bool) *InterceptingRoundTripper {
+	return &InterceptingRoundTripper{
+		Interceptor: interceptor,
+		Blocking:    blocking,
+		Transport:   transport,
+	}
+}

tests/unit/client_config_test.go

@@ -18,8 +18,11 @@ package unit
 
 import (
 	"context"
+	"fmt"
+	"net/http"
 	"testing"
 
+	"github.com/jarcoal/httpmock"
 	"github.com/okta/okta-sdk-golang/v2/okta"
 
 	"github.com/okta/okta-sdk-golang/v2/tests"
@@ -90,3 +93,110 @@ func Test_will_error_if_private_key_authorization_type_with_missing_properties(t
 	_, _, err := tests.NewClient(context.TODO(), okta.WithAuthorizationMode("PrivateKey"), okta.WithClientId(""))
 	assert.Error(t, err, "Does not error if private key selected with no other required options")
 }
+
+type InterceptingRoundTripperTest struct {
+	Name                    string
+	Blocking                bool
+	Interceptor             func(*http.Request) error
+	ExpectedTransportCalls  int
+	ExpectInterceptorCalled bool
+	ExpectSdkErrorThrown    bool
+}
+
+func Test_Intercepting_RoundTripper(t *testing.T) {
+	interceptorCalled := false
+	testsToRun := []InterceptingRoundTripperTest{
+		{
+			Name:     "Calls interceptor",
+			Blocking: false,
+			Interceptor: func(r *http.Request) error {
+				interceptorCalled = true
+				return nil
+			},
+			ExpectedTransportCalls:  1,
+			ExpectInterceptorCalled: true,
+			ExpectSdkErrorThrown:    false,
+		},
+		{
+			Name:     "Does not call transport when interceptor panics when blocking",
+			Blocking: true,
+			Interceptor: func(r *http.Request) error {
+				interceptorCalled = true
+				panic("Some err")
+			},
+			ExpectedTransportCalls:  0,
+			ExpectInterceptorCalled: true,
+			ExpectSdkErrorThrown:    true,
+		},
+		{
+			Name:     "Calls transport when interceptor panics when non blocking",
+			Blocking: false,
+			Interceptor: func(r *http.Request) error {
+				interceptorCalled = true
+				panic("Some err")
+			},
+			ExpectedTransportCalls:  1,
+			ExpectInterceptorCalled: true,
+			ExpectSdkErrorThrown:    false,
+		},
+		{
+			Name:     "Does not call transport when interceptor throws err when blocking",
+			Blocking: true,
+			Interceptor: func(r *http.Request) error {
+				interceptorCalled = true
+				return fmt.Errorf("Some error")
+			},
+			ExpectedTransportCalls:  0,
+			ExpectInterceptorCalled: true,
+			ExpectSdkErrorThrown:    true,
+		},
+		{
+			Name:     "Calls transport when interceptor throws err when not blocking",
+			Blocking: false,
+			Interceptor: func(r *http.Request) error {
+				interceptorCalled = true
+				return fmt.Errorf("Some error")
+			},
+			ExpectedTransportCalls:  1,
+			ExpectInterceptorCalled: true,
+			ExpectSdkErrorThrown:    false,
+		},
+	}
+
+	for _, test := range testsToRun {
+		t.Run(
+			test.Name,
+			func(t *testing.T) {
+				mockHttpClient := http.DefaultClient
+				mockTransport := httpmock.DefaultTransport
+				mockTransport.RegisterNoResponder(func(r *http.Request) (*http.Response, error) {
+					return &http.Response{StatusCode: 200}, nil
+				})
+				mockHttpClient.Transport = mockTransport
+
+				_, oktaClient, err := tests.NewClient(
+					context.TODO(),
+					okta.WithHttpInterceptorAndHttpClientPtr(test.Interceptor, mockHttpClient, test.Blocking),
+				)
+				assert.NoError(t, err)
+
+				_, _, err = oktaClient.IdentityProvider.ActivateIdentityProvider(context.TODO(), "Anything")
+
+				if test.ExpectSdkErrorThrown {
+					assert.Error(t, err)
+				} else {
+					assert.NoError(t, err)
+				}
+
+				assert.Equal(t, test.ExpectInterceptorCalled, interceptorCalled)
+
+				callCount := mockTransport.GetTotalCallCount()
+
+				assert.Equal(t, test.ExpectedTransportCalls, callCount)
+
+				interceptorCalled = false
+				mockTransport.ZeroCallCounters()
+			},
+		)
+	}
+}