Update to latest internal module (Azure#20553)

Removed LRO and payload helpers that are now in the internal module.
Complimentary to Azure#20539

Author: jhendrixMSFT

sdk/azcore/CHANGELOG.md

@@ -14,6 +14,7 @@
 * Added non-conformant LRO terminal states `Cancelled` and `Completed`.
 
 ### Other Changes
+* Updated to latest `internal` module.
 
 ## 1.5.0-beta.1 (2023-03-02)
 

sdk/azcore/go.mod

@@ -3,7 +3,7 @@ module github.com/Azure/azure-sdk-for-go/sdk/azcore
 go 1.18
 
 require (
-	github.com/Azure/azure-sdk-for-go/sdk/internal v1.2.0
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0
 	github.com/stretchr/testify v1.7.0
 	golang.org/x/net v0.8.0
 )

sdk/azcore/go.sum

@@ -1,5 +1,5 @@
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.2.0 h1:leh5DwKv6Ihwi+h60uHtn6UWAxBbZ0q8DwQVMzf61zw=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.2.0/go.mod h1:eWRD7oawr1Mu1sLCawqVc0CUiF43ia3qQMxLscsKQ9w=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0 h1:sXr+ck84g/ZlZUOZiNELInmMgOsuGwdjjVkEIde0OtY=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0/go.mod h1:okt5dMMTOFjX/aovMlrjvvXoPMBVSPzk9185BT0+eZM=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

sdk/azcore/internal/exported/exported.go

@@ -11,8 +11,6 @@ import (
 	"io"
 	"net/http"
 	"time"
-
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared"
 )
 
 type nopCloser struct {
@@ -43,24 +41,6 @@ func HasStatusCode(resp *http.Response, statusCodes ...int) bool {
 	return false
 }
 
-// Payload reads and returns the response body or an error.
-// On a successful read, the response body is cached.
-// Subsequent reads will access the cached value.
-// Exported as runtime.Payload().
-func Payload(resp *http.Response) ([]byte, error) {
-	// r.Body won't be a nopClosingBytesReader if downloading was skipped
-	if buf, ok := resp.Body.(*shared.NopClosingBytesReader); ok {
-		return buf.Bytes(), nil
-	}
-	bytesBody, err := io.ReadAll(resp.Body)
-	resp.Body.Close()
-	if err != nil {
-		return nil, err
-	}
-	resp.Body = shared.NewNopClosingBytesReader(bytesBody)
-	return bytesBody, nil
-}
-
 // AccessToken represents an Azure service bearer access token with expiry information.
 // Exported as azcore.AccessToken.
 type AccessToken struct {

sdk/azcore/internal/exported/exported_test.go

@@ -7,7 +7,6 @@
 package exported
 
 import (
-	"io"
 	"net/http"
 	"strings"
 	"testing"
@@ -34,24 +33,3 @@ func TestHasStatusCode(t *testing.T) {
 		t.Fatal("unexpected failure")
 	}
 }
-
-func TestPayload(t *testing.T) {
-	const val = "payload"
-	resp := &http.Response{
-		Body: io.NopCloser(strings.NewReader(val)),
-	}
-	b, err := Payload(resp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(b) != val {
-		t.Fatalf("got %s, want %s", string(b), val)
-	}
-	b, err = Payload(resp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(b) != val {
-		t.Fatalf("got %s, want %s", string(b), val)
-	}
-}

sdk/azcore/internal/exported/response_error.go

@@ -12,6 +12,8 @@ import (
 	"fmt"
 	"net/http"
 	"regexp"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/internal/exported"
 )
 
 // NewResponseError creates a new *ResponseError from the provided HTTP response.
@@ -29,7 +31,7 @@ func NewResponseError(resp *http.Response) error {
 	}
 
 	// if we didn't get x-ms-error-code, check in the response body
-	body, err := Payload(resp)
+	body, err := exported.Payload(resp, nil)
 	if err != nil {
 		return err
 	}
@@ -121,7 +123,7 @@ func (e *ResponseError) Error() string {
 		fmt.Fprintln(msg, "ERROR CODE UNAVAILABLE")
 	}
 	fmt.Fprintln(msg, "--------------------------------------------------------------------------------")
-	body, err := Payload(e.RawResponse)
+	body, err := exported.Payload(e.RawResponse, nil)
 	if err != nil {
 		// this really shouldn't fail at this point as the response
 		// body is already cached (it was read in NewResponseError)

sdk/azcore/internal/pollers/async/async.go

@@ -16,6 +16,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared"
+	"github.com/Azure/azure-sdk-for-go/sdk/internal/poller"
 )
 
 // see https://github.com/Azure/azure-resource-manager-rpc/blob/master/v1.0/async-api-reference.md
@@ -68,15 +69,15 @@ func New[T any](pl exported.Pipeline, resp *http.Response, finalState pollers.Fi
 	if asyncURL == "" {
 		return nil, errors.New("response is missing Azure-AsyncOperation header")
 	}
-	if !pollers.IsValidURL(asyncURL) {
+	if !poller.IsValidURL(asyncURL) {
 		return nil, fmt.Errorf("invalid polling URL %s", asyncURL)
 	}
 	// check for provisioning state.  if the operation is a RELO
 	// and terminates synchronously this will prevent extra polling.
 	// it's ok if there's no provisioning state.
-	state, _ := pollers.GetProvisioningState(resp)
+	state, _ := poller.GetProvisioningState(resp)
 	if state == "" {
-		state = pollers.StatusInProgress
+		state = poller.StatusInProgress
 	}
 	p := &Poller[T]{
 		pl:         pl,
@@ -93,17 +94,17 @@ func New[T any](pl exported.Pipeline, resp *http.Response, finalState pollers.Fi
 
 // Done returns true if the LRO is in a terminal state.
 func (p *Poller[T]) Done() bool {
-	return pollers.IsTerminalState(p.CurState)
+	return poller.IsTerminalState(p.CurState)
 }
 
 // Poll retrieves the current state of the LRO.
 func (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {
 	err := pollers.PollHelper(ctx, p.AsyncURL, p.pl, func(resp *http.Response) (string, error) {
-		if !pollers.StatusCodeValid(resp) {
+		if !poller.StatusCodeValid(resp) {
 			p.resp = resp
 			return "", exported.NewResponseError(resp)
 		}
-		state, err := pollers.GetStatus(resp)
+		state, err := poller.GetStatus(resp)
 		if err != nil {
 			return "", err
 		} else if state == "" {
@@ -122,7 +123,7 @@ func (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {
 func (p *Poller[T]) Result(ctx context.Context, out *T) error {
 	if p.resp.StatusCode == http.StatusNoContent {
 		return nil
-	} else if pollers.Failed(p.CurState) {
+	} else if poller.Failed(p.CurState) {
 		return exported.NewResponseError(p.resp)
 	}
 	var req *exported.Request
@@ -154,5 +155,5 @@ func (p *Poller[T]) Result(ctx context.Context, out *T) error {
 		p.resp = resp
 	}
 
-	return pollers.ResultHelper(p.resp, pollers.Failed(p.CurState), out)
+	return pollers.ResultHelper(p.resp, poller.Failed(p.CurState), out)
 }

sdk/azcore/internal/pollers/async/async_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared"
+	"github.com/Azure/azure-sdk-for-go/sdk/internal/poller"
 	"github.com/stretchr/testify/require"
 )
 
@@ -55,29 +56,29 @@ func TestCanResume(t *testing.T) {
 }
 
 func TestNew(t *testing.T) {
-	poller, err := New[struct{}](exported.Pipeline{}, nil, "")
+	ap, err := New[struct{}](exported.Pipeline{}, nil, "")
 	require.NoError(t, err)
-	require.Empty(t, poller.CurState)
+	require.Empty(t, ap.CurState)
 
-	poller, err = New[struct{}](exported.Pipeline{}, &http.Response{Header: http.Header{}}, "")
+	ap, err = New[struct{}](exported.Pipeline{}, &http.Response{Header: http.Header{}}, "")
 	require.Error(t, err)
-	require.Nil(t, poller)
+	require.Nil(t, ap)
 
 	resp := initialResponse(http.MethodPut, http.NoBody)
 	resp.Header.Set(shared.HeaderAzureAsync, "this is an invalid polling URL")
-	poller, err = New[struct{}](exported.Pipeline{}, resp, "")
+	ap, err = New[struct{}](exported.Pipeline{}, resp, "")
 	require.Error(t, err)
-	require.Nil(t, poller)
+	require.Nil(t, ap)
 
 	resp = initialResponse(http.MethodPut, http.NoBody)
 	resp.Header.Set(shared.HeaderAzureAsync, fakePollingURL)
 	resp.Header.Set(shared.HeaderLocation, fakeResourceURL)
-	poller, err = New[struct{}](exported.Pipeline{}, resp, "")
+	ap, err = New[struct{}](exported.Pipeline{}, resp, "")
 	require.NoError(t, err)
-	require.Equal(t, fakePollingURL, poller.AsyncURL)
-	require.Equal(t, fakeResourceURL, poller.LocURL)
-	require.Equal(t, pollers.StatusInProgress, poller.CurState)
-	require.False(t, poller.Done())
+	require.Equal(t, fakePollingURL, ap.AsyncURL)
+	require.Equal(t, fakeResourceURL, ap.LocURL)
+	require.Equal(t, poller.StatusInProgress, ap.CurState)
+	require.False(t, ap.Done())
 }
 
 func TestNewDeleteNoProvState(t *testing.T) {
@@ -273,10 +274,10 @@ func TestSynchronousCompletion(t *testing.T) {
 	resp := initialResponse(http.MethodPut, io.NopCloser(strings.NewReader(`{ "properties": { "provisioningState": "Succeeded" } }`)))
 	resp.Header.Set(shared.HeaderAzureAsync, fakePollingURL)
 	resp.Header.Set(shared.HeaderLocation, fakeResourceURL)
-	poller, err := New[struct{}](exported.Pipeline{}, resp, "")
+	ap, err := New[struct{}](exported.Pipeline{}, resp, "")
 	require.NoError(t, err)
-	require.Equal(t, fakePollingURL, poller.AsyncURL)
-	require.Equal(t, fakeResourceURL, poller.LocURL)
-	require.Equal(t, pollers.StatusSucceeded, poller.CurState)
-	require.True(t, poller.Done())
+	require.Equal(t, fakePollingURL, ap.AsyncURL)
+	require.Equal(t, fakeResourceURL, ap.LocURL)
+	require.Equal(t, poller.StatusSucceeded, ap.CurState)
+	require.True(t, ap.Done())
 }

sdk/azcore/internal/pollers/body/body.go

@@ -14,6 +14,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers"
+	"github.com/Azure/azure-sdk-for-go/sdk/internal/poller"
 )
 
 // Kind is the identifier of this type in a resume token.
@@ -72,9 +73,9 @@ func New[T any](pl exported.Pipeline, resp *http.Response) (*Poller[T], error) {
 	}
 	// default initial state to InProgress.  depending on the HTTP
 	// status code and provisioning state, we might change the value.
-	curState := pollers.StatusInProgress
-	provState, err := pollers.GetProvisioningState(resp)
-	if err != nil && !errors.Is(err, pollers.ErrNoBody) {
+	curState := poller.StatusInProgress
+	provState, err := poller.GetProvisioningState(resp)
+	if err != nil && !errors.Is(err, poller.ErrNoBody) {
 		return nil, err
 	}
 	if resp.StatusCode == http.StatusCreated && provState != "" {
@@ -85,37 +86,37 @@ func New[T any](pl exported.Pipeline, resp *http.Response) (*Poller[T], error) {
 			curState = provState
 		} else if provState == "" {
 			// for a 200, absense of provisioning state indicates success
-			curState = pollers.StatusSucceeded
+			curState = poller.StatusSucceeded
 		}
 	} else if resp.StatusCode == http.StatusNoContent {
-		curState = pollers.StatusSucceeded
+		curState = poller.StatusSucceeded
 	}
 	p.CurState = curState
 	return p, nil
 }
 
 func (p *Poller[T]) Done() bool {
-	return pollers.IsTerminalState(p.CurState)
+	return poller.IsTerminalState(p.CurState)
 }
 
 func (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {
 	err := pollers.PollHelper(ctx, p.PollURL, p.pl, func(resp *http.Response) (string, error) {
-		if !pollers.StatusCodeValid(resp) {
+		if !poller.StatusCodeValid(resp) {
 			p.resp = resp
 			return "", exported.NewResponseError(resp)
 		}
 		if resp.StatusCode == http.StatusNoContent {
 			p.resp = resp
-			p.CurState = pollers.StatusSucceeded
+			p.CurState = poller.StatusSucceeded
 			return p.CurState, nil
 		}
-		state, err := pollers.GetProvisioningState(resp)
-		if errors.Is(err, pollers.ErrNoBody) {
+		state, err := poller.GetProvisioningState(resp)
+		if errors.Is(err, poller.ErrNoBody) {
 			// a missing response body in non-204 case is an error
 			return "", err
 		} else if state == "" {
 			// a response body without provisioning state is considered terminal success
-			state = pollers.StatusSucceeded
+			state = poller.StatusSucceeded
 		} else if err != nil {
 			return "", err
 		}
@@ -130,5 +131,5 @@ func (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {
 }
 
 func (p *Poller[T]) Result(ctx context.Context, out *T) error {
-	return pollers.ResultHelper(p.resp, pollers.Failed(p.CurState), out)
+	return pollers.ResultHelper(p.resp, poller.Failed(p.CurState), out)
 }

sdk/azcore/internal/pollers/body/body_test.go

@@ -15,8 +15,8 @@ import (
 	"testing"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported"
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared"
+	"github.com/Azure/azure-sdk-for-go/sdk/internal/poller"
 	"github.com/stretchr/testify/require"
 )
 
@@ -62,33 +62,33 @@ func TestCanResume(t *testing.T) {
 }
 
 func TestNew(t *testing.T) {
-	poller, err := New[struct{}](exported.Pipeline{}, nil)
+	bp, err := New[struct{}](exported.Pipeline{}, nil)
 	require.NoError(t, err)
-	require.Empty(t, poller.CurState)
+	require.Empty(t, bp.CurState)
 
 	resp := initialResponse(http.MethodPut, strings.NewReader(`{ "properties": { "provisioningState": "Started" } }`))
 	resp.StatusCode = http.StatusCreated
-	poller, err = New[struct{}](exported.Pipeline{}, resp)
+	bp, err = New[struct{}](exported.Pipeline{}, resp)
 	require.NoError(t, err)
-	require.Equal(t, "Started", poller.CurState)
+	require.Equal(t, "Started", bp.CurState)
 
 	resp = initialResponse(http.MethodPut, strings.NewReader(`{ "properties": { "provisioningState": "Started" } }`))
 	resp.StatusCode = http.StatusOK
-	poller, err = New[struct{}](exported.Pipeline{}, resp)
+	bp, err = New[struct{}](exported.Pipeline{}, resp)
 	require.NoError(t, err)
-	require.Equal(t, "Started", poller.CurState)
+	require.Equal(t, "Started", bp.CurState)
 
 	resp = initialResponse(http.MethodPut, http.NoBody)
 	resp.StatusCode = http.StatusOK
-	poller, err = New[struct{}](exported.Pipeline{}, resp)
+	bp, err = New[struct{}](exported.Pipeline{}, resp)
 	require.NoError(t, err)
-	require.Equal(t, pollers.StatusSucceeded, poller.CurState)
+	require.Equal(t, poller.StatusSucceeded, bp.CurState)
 
 	resp = initialResponse(http.MethodPut, http.NoBody)
 	resp.StatusCode = http.StatusNoContent
-	poller, err = New[struct{}](exported.Pipeline{}, resp)
+	bp, err = New[struct{}](exported.Pipeline{}, resp)
 	require.NoError(t, err)
-	require.Equal(t, pollers.StatusSucceeded, poller.CurState)
+	require.Equal(t, poller.StatusSucceeded, bp.CurState)
 }
 
 type widget struct {
@@ -98,18 +98,18 @@ type widget struct {
 func TestUpdateNoProvStateFail(t *testing.T) {
 	resp := initialResponse(http.MethodPut, strings.NewReader(`{ "properties": { "provisioningState": "Started" } }`))
 	resp.StatusCode = http.StatusOK
-	poller, err := New[widget](exported.NewPipeline(shared.TransportFunc(func(req *http.Request) (*http.Response, error) {
+	bp, err := New[widget](exported.NewPipeline(shared.TransportFunc(func(req *http.Request) (*http.Response, error) {
 		return &http.Response{
 			StatusCode: http.StatusOK,
 			Body:       http.NoBody,
 		}, nil
 	})), resp)
 	require.NoError(t, err)
-	require.False(t, poller.Done())
-	resp, err = poller.Poll(context.Background())
-	require.ErrorIs(t, err, pollers.ErrNoBody)
+	require.False(t, bp.Done())
+	resp, err = bp.Poll(context.Background())
+	require.ErrorIs(t, err, poller.ErrNoBody)
 	require.Nil(t, resp)
-	require.False(t, poller.Done())
+	require.False(t, bp.Done())
 }
 
 func TestUpdateNoProvStateSuccess(t *testing.T) {