Improperly embedded core.PageIterator2[T] in tableapi.TablePageIterator

Author: michaeldcanady

changelog.md

@@ -19,6 +19,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Fixed
 
+- Improperly embedded `core.PageIterator2[T]` in `tableapi.TablePageIterator` ([Issue #105](https://github.com/michaeldcanady/servicenow-sdk-go/issues/105))
+
 ## [1.5.0] - (02/03/2024)
 
 ### Added

internal/authorization_provider.go

@@ -1,24 +1,9 @@
 package internal
 
 const (
-	AuthorizationHeader = "Authorization"
+	authorizationHeader = "Authorization"
 )
 
-type Credential interface {
-	GetAuthentication() (string, error)
-}
-
 type AuthorizationProvider interface {
 	AuthorizeRequest(request RequestInformation) error
 }
-
-type BasicAuthorizationProvider struct {
-	credential Credential
-}
-
-func (b *BasicAuthorizationProvider) AuthorizeRequest(request RequestInformation) error {
-	header, err := b.credential.GetAuthentication()
-	if err != nil {
-		return err
-	}
-}

internal/basic_authorization_provider.go

@@ -0,0 +1,30 @@
+package internal
+
+import "net/http"
+
+type BaseAuthorizationProvider struct {
+	credential Credential
+}
+
+func NewBaseAuthorizationProvider(credential Credential) *BaseAuthorizationProvider {
+	return &BaseAuthorizationProvider{
+		credential: credential,
+	}
+}
+
+func (b *BaseAuthorizationProvider) AuthorizeRequest(request RequestInformation) error {
+	headerString, err := b.credential.GetAuthentication()
+	if err != nil {
+		return err
+	}
+
+	newHeaders := http.Header{}
+	newHeaders.Set(authorizationHeader, headerString)
+
+	err = request.AddHeaders(newHeaders)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/credential.go

@@ -0,0 +1,5 @@
+package internal
+
+type Credential interface {
+	GetAuthentication() (string, error)
+}

internal/request_information.go

@@ -1,7 +1,6 @@
 package internal
 
 import (
-	"bytes"
 	"context"
 	"net/http"
 	"net/url"
@@ -10,7 +9,6 @@ import (
 type RequestInformation interface {
 	SetStreamContent(content []byte)
 	AddQueryParameters(source interface{}) error
-	getContentReader() *bytes.Reader
 	SetUri(url *url.URL)  //nolint:stylecheck
 	Url() (string, error) //nolint:stylecheck
 	ToRequest() (*http.Request, error)

servicenow_client_test.go

@@ -6,15 +6,18 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"reflect"
 	"strings"
 	"testing"
 
 	"github.com/michaeldcanady/servicenow-sdk-go/core"
 	"github.com/michaeldcanady/servicenow-sdk-go/credentials"
+	"github.com/mozillazg/go-httpheader"
 	"github.com/stretchr/testify/assert"
 )
 
 type MockRequestInformation struct {
+	Headers http.Header
 }
 
 func (rI *MockRequestInformation) AddRequestOptions(options []core.RequestOption) {
@@ -44,10 +47,43 @@ func (rI *MockRequestInformation) ToRequest() (*http.Request, error) {
 }
 
 func (rI *MockRequestInformation) ToRequestWithContext(ctx context.Context) (*http.Request, error) {
-	return http.NewRequestWithContext(ctx, "GET", "https://www.example.com", nil)
+
+	request, err := http.NewRequestWithContext(ctx, "GET", "https://www.example.com", nil)
+	if err != nil {
+		return nil, err
+	}
+	request.Header = rI.Headers
+
+	return request, nil
 }
 
 func (rI *MockRequestInformation) AddHeaders(rawHeaders interface{}) error {
+	var headers http.Header
+	var err error
+
+	val := reflect.ValueOf(rawHeaders)
+
+	if val.Kind() == reflect.Struct {
+		// use the httpheader.Encode function from the httpheader package
+		// to encode the pointer value into an http.Header map
+		headers, err = httpheader.Encode(rawHeaders)
+		if err != nil {
+			return err
+		}
+	} else if val.Type() == reflect.TypeOf(http.Header{}) {
+		// if the value is already an http.Header map, just assign it to headers
+		headers = rawHeaders.(http.Header)
+	} else {
+		// otherwise, return an error
+		return core.ErrInvalidHeaderType
+	}
+
+	// iterate over the headers map and add each key-value pair to rI.Headers
+	for key, values := range headers {
+		for _, value := range values {
+			rI.Headers.Add(key, value)
+		}
+	}
 	return nil
 }
 
@@ -141,7 +177,9 @@ func TestClientUnmarshallError(t *testing.T) {
 }
 
 func TestClientToRequestWithContext(t *testing.T) {
-	requestInfo := &MockRequestInformation{}
+	requestInfo := &MockRequestInformation{
+		Headers: http.Header{},
+	}
 
 	cred := credentials.NewUsernamePasswordCredential("username", "password")
 

table-api/table_page_iterator.go

@@ -7,12 +7,48 @@ import (
 	"github.com/michaeldcanady/servicenow-sdk-go/internal"
 )
 
-// TablePageIterato2[T] is an iterator over pages of table entries.
+// TablePageIterator is a generic struct in Golang which is used to iterate over pages of entries.
+// It embeds the core.PageIterator2 struct and can be used with any type that satisfies the Entry interface.
+//
+// Fields:
+//   - core.PageIterator2[T]: This is an embedded field of type PageIterator2 from the core package.
+//     The type T represents the type of Entry that the iterator will return.
+//
+// Usage:
+// You can use this struct to iterate over pages of entries in a table.
+// The specific type of Entry depends on what you specify for T when you create an instance of TablePageIterator.
 type TablePageIterator[T Entry] struct {
-	// pageIterator is the core page iterator that this table page iterator wraps.
-	pageIterator core.PageIterator2[T]
+	*core.PageIterator2[T]
 }
 
+// constructTableCollection is a generic function in Golang used to construct a collection of table entries.
+// It takes an http.Response pointer as input and returns a CollectionResponse of the specified Entry type and an error.
+//
+// Parameters:
+// * response: This is a pointer to an http.Response that contains the server's response to an HTTP request.
+//
+// Returns:
+// * core.CollectionResponse[T]: This is a CollectionResponse of the specified Entry type. It represents the collection of table entries.
+// * error: This is an error that will be returned if there is any error while parsing the response.
+//
+// Usage:
+// You can use this function to construct a collection of table entries from an *http.Response.
+//
+//	func ExampleConstructTableCollectionF() {
+//		response, err := http.Get("http://example.com")
+//
+//		if err != nil {
+//	    	log.Fatal(err)
+//		}
+//
+//		collection, err := constructTableCollection[MyEntryType](response)
+//
+//		if err != nil {
+//	    	log.Fatal(err)
+//		}
+//
+//		// Process collection
+//	}
 func constructTableCollection[T Entry](response *http.Response) (core.CollectionResponse[T], error) {
 	resp := &TableCollectionResponse2[T]{}
 
@@ -23,14 +59,40 @@ func constructTableCollection[T Entry](response *http.Response) (core.Collection
 	return resp, nil
 }
 
-// NewTablePageIterator[T] creates a new TablePageIterator2 instance.
+// NewTablePageIterator is a function that creates a new instance of TablePageIterator.
+// It takes a TableCollectionResponse and a Client as input and returns a pointer to a TablePageIterator and an error.
+//
+// Parameters:
+//
+//   - collection: This is a pointer to a TableCollectionResponse that contains the collection of table entries.
+//   - client: This is a Client that will be used to make requests to the server.
+//
+// Returns:
+//
+//   - *TablePageIterator[T]: This is a pointer to a TablePageIterator that can be used to iterate over the pages of entries in the collection.
+//   - error: This is an error that will be returned if there is any error while creating the PageIterator.
+//
+// Usage:
+// You can use this function to create a new instance of TablePageIterator.
+//
+//		func ExampleNewTablePageIteratorF() {
+//			// use an existing collection
+//			var collection TableCollectionResponse2[T]
+//			// use a new or existing client
+//			var client core.Client
+//			iter, err := NewTablePageIterator[T](collection, client)
+//			if err != nil {
+//	    		log.Fatal(err)
+//			}
+//			// Use iter to iterate over the pages of entries
+//		}
 func NewTablePageIterator[T Entry](collection *TableCollectionResponse2[T], client core.Client) (*TablePageIterator[T], error) {
 	pageIterator, err := core.NewPageIterator2[T](collection, client, constructTableCollection[T])
 	if err != nil {
 		return nil, err
 	}
 
 	return &TablePageIterator[T]{
-		pageIterator: (*pageIterator),
+		pageIterator,
 	}, nil
 }