feat: implement field endpoints

2026-03-25 16:36:53 -05:00
parent 0063830cfb
commit ce85b08fbc
7 changed files with 1324 additions and 20 deletions
@@ -0,0 +1,935 @@
+package onspring_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"reflect"
+	"slices"
+	"strconv"
+	"testing"
+
+	"github.com/StevanFreeborn/onspring-api-sdk-go"
+)
+
+func TestFields(t *testing.T) {
+	t.Run("Get", func(t *testing.T) {
+		t.Run("it should return an error if context is nil", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			var nilContext context.Context = nil
+
+			_, err := client.Fields.Get(nilContext, 0)
+
+			if err == nil {
+				t.Errorf("Expected error for nil context, got nil")
+			}
+		})
+
+		t.Run("it should return an error if context is canceled", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			ctx, cancel := context.WithCancel(t.Context())
+
+			cancel()
+
+			_, err := client.Fields.List(ctx, 0)
+
+			if err == nil {
+				t.Errorf("Expected error for canceled context, got nil")
+			}
+		})
+
+		t.Run("it should return an error if encounters a network error", func(t *testing.T) {
+			client := onspring.NewClient(
+				"test-api-key",
+				onspring.WithBaseURL("http://invalid-url"),
+				onspring.WithHTTPClient(&http.Client{Transport: &ErrorTransport{}}),
+			)
+
+			_, err := client.Fields.Get(t.Context(), 0)
+
+			if err == nil {
+				t.Errorf("Expected network error, got nil")
+			}
+		})
+
+		t.Run("it should return an error if create a request fails", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			invalidClient := onspring.NewClient(
+				"test-api-key",
+				onspring.WithBaseURL("http://[::1]:namedport"),
+				onspring.WithHTTPClient(client.HTTPClient()),
+			)
+
+			_, err := invalidClient.Fields.Get(t.Context(), 0)
+
+			if err == nil {
+				t.Errorf("Expected request creation error, got nil")
+			}
+		})
+
+		t.Run("it should return an error if the /fields/id/:id endpoint returns a non-200 status code", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			})
+
+			_, err := client.Fields.Get(t.Context(), 0)
+
+			if err == nil {
+				t.Errorf("Expected error, got nil")
+			}
+		})
+
+		t.Run("it should return a field if the /fields/id/:id endpoint returns a 200 status code", func(t *testing.T) {
+			expectedField := onspring.Field{
+				Id:         1,
+				AppId:      1,
+				Name:       "Field",
+				Type:       "Text",
+				Status:     "Enabled",
+				IsRequired: true,
+				IsUnique:   false,
+			}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet {
+					t.Errorf("Expected GET method, got %s", r.Method)
+				}
+
+				expectedPath := fmt.Sprintf("/fields/id/%d", expectedField.Id)
+
+				if r.URL.Path != expectedPath {
+					t.Errorf("Expected %s endpoint, got %s", expectedPath, r.URL.Path)
+				}
+
+				jsonData, _ := json.Marshal(expectedField)
+
+				w.WriteHeader(http.StatusOK)
+				w.Header().Set("Content-Type", "application/json")
+				_, _ = w.Write(jsonData)
+			})
+
+			field, _ := client.Fields.Get(t.Context(), expectedField.Id)
+
+			if !reflect.DeepEqual(expectedField, field) {
+				t.Errorf("Expected %v but got %v", expectedField, field)
+			}
+		})
+
+	})
+
+	t.Run("UnmarshalJSON", func(t *testing.T) {
+		t.Run("it should unmarshal a Formula field correctly", func(t *testing.T) {
+			jsonStr := `{
+				"id": 1,
+				"appId": 10,
+				"name": "Calc Field",
+				"type": "Formula",
+				"status": "Enabled",
+				"isRequired": true,
+				"isUnique": false,
+				"outputType": "Number",
+				"values": ["1", "2", "3"]
+			}`
+
+			var field onspring.Field
+
+			err := json.Unmarshal([]byte(jsonStr), &field)
+
+			if err != nil {
+				t.Fatalf("UnmarshalJSON failed: %v", err)
+			}
+
+			if field.Type != "Formula" {
+				t.Errorf("Expected Type 'Formula', got %s", field.Type)
+			}
+
+			formulaField, ok := field.TypeData.(onspring.FormulaField)
+
+			if !ok {
+				t.Fatalf("Expected TypeData to be FormulaField, got %T", field.TypeData)
+			}
+
+			expectedFormulaField := onspring.FormulaField{
+				OutputType: "Number",
+				Values:     []string{"1", "2", "3"},
+			}
+
+			if !reflect.DeepEqual(formulaField, expectedFormulaField) {
+				t.Errorf("Expected FormulaField %+v, got %+v", expectedFormulaField, formulaField)
+			}
+		})
+
+		t.Run("it should unmarshal a Reference field correctly", func(t *testing.T) {
+			jsonStr := `{
+				"id": 2,
+				"appId": 20,
+				"name": "Ref Field",
+				"type": "Reference",
+				"status": "Enabled",
+				"isRequired": false,
+				"isUnique": true,
+				"multiplicity": "OneToOne",
+				"referenceAppId": "123"
+			}`
+
+			var field onspring.Field
+
+			err := json.Unmarshal([]byte(jsonStr), &field)
+
+			if err != nil {
+				t.Fatalf("UnmarshalJSON failed: %v", err)
+			}
+
+			if field.Type != "Reference" {
+				t.Errorf("Expected Type 'Reference', got %s", field.Type)
+			}
+
+			referenceField, ok := field.TypeData.(onspring.ReferenceField)
+
+			if !ok {
+				t.Fatalf("Expected TypeData to be ReferenceField, got %T", field.TypeData)
+			}
+
+			expectedReferenceField := onspring.ReferenceField{
+				Multiplicity:   "OneToOne",
+				ReferenceAppId: "123",
+			}
+
+			if !reflect.DeepEqual(referenceField, expectedReferenceField) {
+				t.Errorf("Expected ReferenceField %+v, got %+v", expectedReferenceField, referenceField)
+			}
+		})
+
+		t.Run("it should unmarshal a List field correctly", func(t *testing.T) {
+			jsonStr := `{
+				"id": 3,
+				"appId": 30,
+				"name": "List Field",
+				"type": "List",
+				"status": "Enabled",
+				"isRequired": false,
+				"isUnique": false,
+				"multiplicity": "MultiSelect",
+				"values": ["OptionA", "OptionB"],
+				"listId": 456
+			}`
+
+			var field onspring.Field
+
+			err := json.Unmarshal([]byte(jsonStr), &field)
+
+			if err != nil {
+				t.Fatalf("UnmarshalJSON failed: %v", err)
+			}
+
+			if field.Type != "List" {
+				t.Errorf("Expected Type 'List', got %s", field.Type)
+			}
+
+			listField, ok := field.TypeData.(onspring.ListField)
+
+			if !ok {
+				t.Fatalf("Expected TypeData to be ListField, got %T", field.TypeData)
+			}
+
+			expectedListField := onspring.ListField{
+				Multiplicity: "MultiSelect",
+				Values:       []string{"OptionA", "OptionB"},
+				ListId:       456,
+			}
+
+			if !reflect.DeepEqual(listField, expectedListField) {
+				t.Errorf("Expected ListField %+v, got %+v", expectedListField, listField)
+			}
+		})
+
+		t.Run("it should handle unknown field types without TypeData", func(t *testing.T) {
+			jsonStr := `{
+				"id": 4,
+				"appId": 40,
+				"name": "Text Field",
+				"type": "Text",
+				"status": "Enabled",
+				"isRequired": true,
+				"isUnique": false
+			}`
+
+			var field onspring.Field
+
+			err := json.Unmarshal([]byte(jsonStr), &field)
+
+			if err != nil {
+				t.Fatalf("UnmarshalJSON failed: %v", err)
+			}
+
+			if field.Type != "Text" {
+				t.Errorf("Expected Type 'Text', got %s", field.Type)
+			}
+
+			if field.TypeData != nil {
+				t.Errorf("Expected TypeData to be nil for 'Text' type, got %+v", field.TypeData)
+			}
+		})
+
+		t.Run("it should return an error for malformed JSON for main field struct", func(t *testing.T) {
+			jsonStr := `{
+				"id": "invalid",
+				"appId": 10,
+				"name": "Calc Field",
+				"type": "Formula"
+			}`
+
+			var field onspring.Field
+
+			err := json.Unmarshal([]byte(jsonStr), &field)
+
+			if err == nil {
+				t.Fatalf("Expected UnmarshalJSON to fail for malformed main struct JSON, got nil")
+			}
+		})
+
+		t.Run("it should return an error for malformed JSON for TypeData (Formula)", func(t *testing.T) {
+			jsonStr := `{
+				"id": 1,
+				"appId": 10,
+				"name": "Calc Field",
+				"type": "Formula",
+				"outputType": 123,
+				"values": ["1", "2", "3"]
+			}`
+
+			var field onspring.Field
+
+			err := json.Unmarshal([]byte(jsonStr), &field)
+
+			if err == nil {
+				t.Fatalf("Expected UnmarshalJSON to fail for malformed Formula TypeData JSON, got nil")
+			}
+		})
+	})
+
+	t.Run("GetMany", func(t *testing.T) {
+		t.Run("it should return an error if context is nil", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			var nilContext context.Context = nil
+
+			_, err := client.Fields.GetMany(nilContext, []int{})
+
+			if err == nil {
+				t.Errorf("Expected error for nil context, got nil")
+			}
+		})
+
+		t.Run("it should return an error if context is canceled", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			ctx, cancel := context.WithCancel(t.Context())
+
+			cancel()
+
+			_, err := client.Fields.GetMany(ctx, []int{})
+
+			if err == nil {
+				t.Errorf("Expected error for canceled context, got nil")
+			}
+		})
+
+		t.Run("it should return an error if encounters a network error", func(t *testing.T) {
+			client := onspring.NewClient(
+				"test-api-key",
+				onspring.WithBaseURL("http://invalid-url"),
+				onspring.WithHTTPClient(&http.Client{Transport: &ErrorTransport{}}),
+			)
+
+			_, err := client.Fields.GetMany(t.Context(), []int{})
+
+			if err == nil {
+				t.Errorf("Expected network error, got nil")
+			}
+		})
+
+		t.Run("it should return an error if create a request fails", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			invalidClient := onspring.NewClient(
+				"test-api-key",
+				onspring.WithBaseURL("http://[::1]:namedport"),
+				onspring.WithHTTPClient(client.HTTPClient()),
+			)
+
+			_, err := invalidClient.Fields.GetMany(t.Context(), []int{})
+
+			if err == nil {
+				t.Errorf("Expected request creation error, got nil")
+			}
+		})
+
+		t.Run("it should return an error if the /fields/batch-get endpoint returns a non-200 status code", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			})
+
+			_, err := client.Fields.GetMany(t.Context(), []int{})
+
+			if err == nil {
+				t.Errorf("Expected error, got nil")
+			}
+		})
+
+		t.Run("it should return a batch of fields when the /fields/batch-get endpoint returns a 200 status code", func(t *testing.T) {
+			fields := []onspring.Field{
+				{
+					Id:         1,
+					AppId:      1,
+					Name:       "Field 1",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+			}
+
+			expectedBatch := onspring.FieldBatch{
+				Count: len(fields),
+				Items: fields,
+			}
+
+			expectedIds := []int{fields[0].Id}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodPost {
+					t.Errorf("Expected POST method, got %s", r.Method)
+				}
+
+				if r.URL.Path != "/fields/batch-get" {
+					t.Errorf("Expected /fields/batch-get endpoint, got %s", r.URL.Path)
+				}
+
+				var ids []int
+				err := json.NewDecoder(r.Body).Decode(&ids)
+
+				if err != nil {
+					t.Errorf("Expected to decode request body, but got error: %v", err)
+				}
+
+				if !slices.Equal(expectedIds, ids) {
+					t.Errorf("Expected body to be %v but got %v", expectedIds, ids)
+				}
+
+				jsonData, _ := json.Marshal(expectedBatch)
+
+				w.WriteHeader(http.StatusOK)
+				w.Header().Set("Content-Type", "application/json")
+				_, _ = w.Write(jsonData)
+			})
+
+			batch, _ := client.Fields.GetMany(t.Context(), expectedIds)
+
+			if !reflect.DeepEqual(expectedBatch, batch) {
+				t.Errorf("Expected %v but got %v", expectedBatch, batch)
+			}
+		})
+	})
+
+	t.Run("List", func(t *testing.T) {
+		t.Run("it should return an error if context is nil", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			var nilContext context.Context = nil
+
+			_, err := client.Fields.List(nilContext, 0)
+
+			if err == nil {
+				t.Errorf("Expected error for nil context, got nil")
+			}
+		})
+
+		t.Run("it should return an error if context is canceled", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			ctx, cancel := context.WithCancel(t.Context())
+
+			cancel()
+
+			_, err := client.Fields.List(ctx, 0)
+
+			if err == nil {
+				t.Errorf("Expected error for canceled context, got nil")
+			}
+		})
+
+		t.Run("it should return an error if encounters a network error", func(t *testing.T) {
+			client := onspring.NewClient(
+				"test-api-key",
+				onspring.WithBaseURL("http://invalid-url"),
+				onspring.WithHTTPClient(&http.Client{Transport: &ErrorTransport{}}),
+			)
+
+			_, err := client.Fields.List(t.Context(), 0)
+
+			if err == nil {
+				t.Errorf("Expected network error, got nil")
+			}
+		})
+
+		t.Run("it should return an error if create a request fails", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			invalidClient := onspring.NewClient(
+				"test-api-key",
+				onspring.WithBaseURL("http://[::1]:namedport"),
+				onspring.WithHTTPClient(client.HTTPClient()),
+			)
+
+			_, err := invalidClient.Fields.List(t.Context(), 0)
+
+			if err == nil {
+				t.Errorf("Expected request creation error, got nil")
+			}
+		})
+
+		t.Run("it should return a page of fields if the /fields/appId/:appId endpoint returns a 200 status code", func(t *testing.T) {
+			appId := 1
+			expectedPageNumber := 1
+			expectedPageSize := 50
+
+			expectedPage := onspring.Page[onspring.Field]{
+				TotalPages:   1,
+				TotalRecords: 1,
+				PageNumber:   1,
+				PageSize:     50,
+				Items: []onspring.Field{
+					{
+						Id:         1,
+						AppId:      appId,
+						Name:       "Field",
+						Type:       "Text",
+						Status:     "Enabled",
+						IsRequired: true,
+						IsUnique:   false,
+					},
+				},
+			}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet {
+					t.Errorf("Expected GET method, got %s", r.Method)
+				}
+
+				expectedPath := fmt.Sprintf("/fields/appId/%d", appId)
+
+				if r.URL.Path != expectedPath {
+					t.Errorf("Expected %s endpoint, got %s", expectedPath, r.URL.Path)
+				}
+
+				pageNumber := r.URL.Query().Get("pageNumber")
+				pageSize := r.URL.Query().Get("pageSize")
+
+				if pageNumber != strconv.Itoa(expectedPageNumber) {
+					t.Errorf("Expected query param pageNumber to be %d but got %s", expectedPageNumber, pageNumber)
+				}
+
+				if pageSize != strconv.Itoa(expectedPageSize) {
+					t.Errorf("Expected query param pageSize to be %d but got %s", expectedPageSize, pageSize)
+				}
+
+				jsonData, _ := json.Marshal(expectedPage)
+
+				w.WriteHeader(http.StatusOK)
+				w.Header().Set("Content-Type", "application/json")
+				_, _ = w.Write(jsonData)
+			})
+
+			page, err := client.Fields.List(t.Context(), appId)
+
+			if err != nil {
+				t.Errorf("Expected no error, got %v", err)
+			}
+
+			if !reflect.DeepEqual(expectedPage, page) {
+				t.Errorf("Expected %v but got %v", expectedPage, page)
+			}
+		})
+
+		t.Run("it should perform a GET request to the /fields/appId/:appId endpoint with non-default paging information when provided", func(t *testing.T) {
+			appId := 1
+			expectedPageNumber := 2
+			expectedPageSize := 1
+
+			expectedPage := onspring.Page[onspring.Field]{
+				TotalPages:   1,
+				TotalRecords: 1,
+				PageNumber:   1,
+				PageSize:     1,
+				Items: []onspring.Field{
+					{
+						Id:         1,
+						AppId:      appId,
+						Name:       "Field",
+						Type:       "Text",
+						Status:     "Enabled",
+						IsRequired: true,
+						IsUnique:   false,
+					},
+				},
+			}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet {
+					t.Errorf("Expected GET method, got %s", r.Method)
+				}
+
+				expectedPath := fmt.Sprintf("/fields/appId/%d", appId)
+
+				if r.URL.Path != expectedPath {
+					t.Errorf("Expected %s endpoint, got %s", expectedPath, r.URL.Path)
+				}
+
+				pageNumber := r.URL.Query().Get("pageNumber")
+				pageSize := r.URL.Query().Get("pageSize")
+
+				if pageNumber != strconv.Itoa(expectedPageNumber) {
+					t.Errorf("Expected query param pageNumber to be %d but got %s", expectedPageNumber, pageNumber)
+				}
+
+				if pageSize != strconv.Itoa(expectedPageSize) {
+					t.Errorf("Expected query param pageSize to be %d but got %s", expectedPageSize, pageSize)
+				}
+
+				jsonData, _ := json.Marshal(expectedPage)
+
+				w.WriteHeader(http.StatusOK)
+				w.Header().Set("Content-Type", "application/json")
+				_, _ = w.Write(jsonData)
+			})
+
+			_, _ = client.Fields.List(
+				t.Context(),
+				appId,
+				onspring.ForPageNumber(expectedPageNumber),
+				onspring.WithPageSize(expectedPageSize),
+			)
+		})
+
+		t.Run("it should return an error if the /fields/appId/:appId endpoint returns a non-200 status code", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			})
+
+			_, err := client.Fields.List(t.Context(), 0)
+
+			if err == nil {
+				t.Errorf("Expected error, got nil")
+			}
+		})
+	})
+
+	t.Run("ListAll", func(t *testing.T) {
+		t.Run("it should return an error if fails to retrieve any pages of fields", func(t *testing.T) {
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			})
+
+			for _, err := range client.Fields.ListAll(t.Context(), 0) {
+				if err == nil {
+					t.Errorf("Expected error, got nil")
+				}
+			}
+		})
+
+		t.Run("it should return all the fields from multiple pages", func(t *testing.T) {
+			appId := 1
+			expectedFields := []onspring.Field{
+				{
+					Id:         1,
+					AppId:      appId,
+					Name:       "Field 1",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+				{
+					Id:         2,
+					AppId:      appId,
+					Name:       "Field 2",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+			}
+
+			pageOne := onspring.Page[onspring.Field]{
+				TotalPages:   2,
+				TotalRecords: 2,
+				PageNumber:   1,
+				PageSize:     1,
+				Items:        []onspring.Field{expectedFields[0]},
+			}
+
+			pageTwo := onspring.Page[onspring.Field]{
+				TotalPages:   2,
+				TotalRecords: 2,
+				PageNumber:   2,
+				PageSize:     1,
+				Items:        []onspring.Field{expectedFields[1]},
+			}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet {
+					t.Errorf("Expected GET method, got %s", r.Method)
+				}
+
+				expectedPath := fmt.Sprintf("/fields/appId/%d", appId)
+				if r.URL.Path != expectedPath {
+					t.Errorf("Expected %s endpoint, got %s", expectedPath, r.URL.Path)
+				}
+
+				pageNumber := r.URL.Query().Get("pageNumber")
+
+				if pageNumber == "1" {
+					jsonData, _ := json.Marshal(pageOne)
+
+					w.WriteHeader(http.StatusOK)
+					w.Header().Set("Content-Type", "application/json")
+					_, _ = w.Write(jsonData)
+				}
+
+				if pageNumber == "2" {
+					jsonData, _ := json.Marshal(pageTwo)
+
+					w.WriteHeader(http.StatusOK)
+					w.Header().Set("Content-Type", "application/json")
+					_, _ = w.Write(jsonData)
+				}
+			})
+
+			retrievedFields := []onspring.Field{}
+
+			for field, _ := range client.Fields.ListAll(t.Context(), appId) {
+				retrievedFields = append(retrievedFields, field)
+			}
+
+			if !slices.Equal(expectedFields, retrievedFields) {
+				t.Errorf("Expected %v but got %v", expectedFields, retrievedFields)
+			}
+		})
+
+		t.Run("it should return fields and errors if some pages fail and some succeed", func(t *testing.T) {
+			appId := 1
+			expectedFields := []onspring.Field{
+				{
+					Id:         1,
+					AppId:      appId,
+					Name:       "Field 1",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+				{
+					Id:         2,
+					AppId:      appId,
+					Name:       "Field 2",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+			}
+
+			page := onspring.Page[onspring.Field]{
+				TotalPages:   2,
+				TotalRecords: 2,
+				PageNumber:   1,
+				PageSize:     1,
+				Items:        expectedFields,
+			}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet {
+					t.Errorf("Expected GET method, got %s", r.Method)
+				}
+
+				expectedPath := fmt.Sprintf("/fields/appId/%d", appId)
+				if r.URL.Path != expectedPath {
+					t.Errorf("Expected %s endpoint, got %s", expectedPath, r.URL.Path)
+				}
+
+				pageNumber := r.URL.Query().Get("pageNumber")
+
+				if pageNumber == "1" {
+					jsonData, _ := json.Marshal(page)
+
+					w.WriteHeader(http.StatusOK)
+					w.Header().Set("Content-Type", "application/json")
+					_, _ = w.Write(jsonData)
+				}
+
+				if pageNumber == "2" {
+					w.WriteHeader(http.StatusInternalServerError)
+				}
+			})
+
+			retrievedFields := []onspring.Field{}
+			encounteredErrors := []error{}
+
+			for field, err := range client.Fields.ListAll(t.Context(), appId) {
+				if err != nil {
+					encounteredErrors = append(encounteredErrors, err)
+				} else {
+					retrievedFields = append(retrievedFields, field)
+				}
+			}
+
+			if !slices.Equal(expectedFields, retrievedFields) {
+				t.Errorf("Expected %v but got %v", expectedFields, retrievedFields)
+			}
+
+			if len(encounteredErrors) != 1 {
+				t.Errorf("Expected to receive one error, but received %d", len(encounteredErrors))
+			}
+		})
+
+		t.Run("it should start paging from specified page number when given", func(t *testing.T) {
+			appId := 1
+			expectedFields := []onspring.Field{
+				{
+					Id:         1,
+					AppId:      appId,
+					Name:       "Field 1",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+				{
+					Id:         2,
+					AppId:      appId,
+					Name:       "Field 2",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+			}
+
+			pageTwo := onspring.Page[onspring.Field]{
+				TotalPages:   2,
+				TotalRecords: 2,
+				PageNumber:   2,
+				PageSize:     1,
+				Items:        expectedFields,
+			}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet {
+					t.Errorf("Expected GET method, got %s", r.Method)
+				}
+
+				expectedPath := fmt.Sprintf("/fields/appId/%d", appId)
+				if r.URL.Path != expectedPath {
+					t.Errorf("Expected %s endpoint, got %s", expectedPath, r.URL.Path)
+				}
+
+				pageNumber := r.URL.Query().Get("pageNumber")
+
+				if pageNumber == "2" {
+					jsonData, _ := json.Marshal(pageTwo)
+
+					w.WriteHeader(http.StatusOK)
+					w.Header().Set("Content-Type", "application/json")
+					_, _ = w.Write(jsonData)
+				}
+			})
+
+			retrievedFields := []onspring.Field{}
+
+			for field, _ := range client.Fields.ListAll(t.Context(), appId, onspring.ForPageNumber(2)) {
+				retrievedFields = append(retrievedFields, field)
+			}
+
+			if !slices.Equal(expectedFields, retrievedFields) {
+				t.Errorf("Expected %v but got %v", expectedFields, retrievedFields)
+			}
+		})
+
+		t.Run("it should retrieve pages using specified page size when given", func(t *testing.T) {
+			appId := 1
+			expectedFields := []onspring.Field{
+				{
+					Id:         1,
+					AppId:      appId,
+					Name:       "Field 1",
+					Type:       "Text",
+					Status:     "Enabled",
+					IsRequired: true,
+					IsUnique:   false,
+				},
+			}
+
+			page := onspring.Page[onspring.Field]{
+				TotalPages:   1,
+				TotalRecords: 1,
+				PageNumber:   1,
+				PageSize:     1,
+				Items:        expectedFields,
+			}
+
+			_, client := setupMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodGet {
+					t.Errorf("Expected GET method, got %s", r.Method)
+				}
+
+				expectedPath := fmt.Sprintf("/fields/appId/%d", appId)
+				if r.URL.Path != expectedPath {
+					t.Errorf("Expected %s endpoint, got %s", expectedPath, r.URL.Path)
+				}
+
+				pageSize := r.URL.Query().Get("pageSize")
+
+				if pageSize == "1" {
+					jsonData, _ := json.Marshal(page)
+
+					w.WriteHeader(http.StatusOK)
+					w.Header().Set("Content-Type", "application/json")
+					_, _ = w.Write(jsonData)
+				}
+			})
+
+			retrievedFields := []onspring.Field{}
+
+			for field, _ := range client.Fields.ListAll(t.Context(), appId, onspring.WithPageSize(1)) {
+				retrievedFields = append(retrievedFields, field)
+			}
+
+			if !slices.Equal(expectedFields, retrievedFields) {
+				t.Errorf("Expected %v but got %v", expectedFields, retrievedFields)
+			}
+		})
+	})
+}