fix iterators parsing

Author: vlboiko

core/interceptors_test.go

@@ -16,32 +16,32 @@ func TestDefaultResponseMutations_PaginationNotUnwrapped(t *testing.T) {
 		"next":     "https://example.com/api/v1/resources/?page=2",
 		"previous": nil,
 	}
-	
+
 	// Apply defaultResponseMutations
 	result, err := defaultResponseMutations(paginationEnvelope)
 	if err != nil {
 		t.Fatalf("Expected no error, got: %v", err)
 	}
-	
+
 	// Verify that the pagination envelope is NOT unwrapped
 	resultRecord, ok := result.(Record)
 	if !ok {
 		t.Fatalf("Expected Record, got %T", result)
 	}
-	
+
 	// Check that the envelope structure is preserved
 	if _, hasResults := resultRecord["results"]; !hasResults {
 		t.Error("Expected results field to be preserved")
 	}
-	
+
 	if _, hasCount := resultRecord["count"]; !hasCount {
 		t.Error("Expected count field to be preserved")
 	}
-	
+
 	if _, hasNext := resultRecord["next"]; !hasNext {
 		t.Error("Expected next field to be preserved")
 	}
-	
+
 	if _, hasPrevious := resultRecord["previous"]; !hasPrevious {
 		t.Error("Expected previous field to be preserved")
 	}
@@ -53,19 +53,19 @@ func TestDefaultResponseMutations_RecordSetUnchanged(t *testing.T) {
 		{"id": float64(1), "name": "item1"},
 		{"id": float64(2), "name": "item2"},
 	}
-	
+
 	// Apply defaultResponseMutations
 	result, err := defaultResponseMutations(recordSet)
 	if err != nil {
 		t.Fatalf("Expected no error, got: %v", err)
 	}
-	
+
 	// Verify that RecordSet is unchanged
 	resultRecordSet, ok := result.(RecordSet)
 	if !ok {
 		t.Fatalf("Expected RecordSet, got %T", result)
 	}
-	
+
 	if len(resultRecordSet) != 2 {
 		t.Errorf("Expected 2 records, got %d", len(resultRecordSet))
 	}
@@ -79,19 +79,19 @@ func TestDefaultResponseMutations_AsyncTask(t *testing.T) {
 			"state": "RUNNING",
 		},
 	}
-	
+
 	// Apply defaultResponseMutations
 	result, err := defaultResponseMutations(asyncTaskResponse)
 	if err != nil {
 		t.Fatalf("Expected no error, got: %v", err)
 	}
-	
+
 	// Verify that async_task is normalized
 	resultRecord, ok := result.(Record)
 	if !ok {
 		t.Fatalf("Expected Record, got %T", result)
 	}
-	
+
 	// Check that ResourceTypeKey was added
 	if resourceType, ok := resultRecord[ResourceTypeKey]; !ok || resourceType != "VTask" {
 		t.Errorf("Expected ResourceTypeKey to be 'VTask', got: %v", resourceType)

core/iterator.go

@@ -146,12 +146,11 @@ func (it *ResourceIterator) fetchPage(url string, params Params) error {
 // processPaginationEnvelope extracts data from a pagination envelope using ToRecordSet.
 func (it *ResourceIterator) processPaginationEnvelope(envelope Record) error {
 	// Check if this is a pagination envelope
+	// Only results and count are required; next and previous are optional
 	_, hasResults := envelope["results"]
 	_, hasCount := envelope["count"]
-	_, hasNext := envelope["next"]
-	_, hasPrev := envelope["previous"]
 
-	if hasResults && hasCount && hasNext && hasPrev {
+	if hasResults && hasCount {
 		// This is a paginated response - use ToRecordSet to convert results
 		if resultsRaw, ok := envelope["results"]; ok {
 			// Try []map[string]any first
@@ -323,7 +322,7 @@ func (it *ResourceIterator) String() string {
 	sb.WriteString(fmt.Sprintf("  Total Count:   %d\n", it.totalCount))
 
 	// Show current records with count
-	if it.current != nil && len(it.current) > 0 {
+	if len(it.current) > 0 {
 		sb.WriteString(fmt.Sprintf("  Current:       [... (%d items)]\n", len(it.current)))
 	} else {
 		sb.WriteString("  Current:       []\n")

core/iterator_test.go

@@ -213,6 +213,102 @@ func TestIterator_NonPaginatedResponse(t *testing.T) {
 	}
 }
 
+// Test response with only count and results (no next/previous fields)
+// This is a common case when there are no results or only one page
+func TestIterator_CountAndResultsOnly(t *testing.T) {
+	// Test case 1: Empty results
+	emptyResponse := Record{
+		"count":   float64(0),
+		"results": []any{},
+	}
+
+	mockSession := &mockSessionForIterator{
+		responses: map[string]Renderable{
+			"https://test.example.com:443/api/v1/resources/?name=vastdb-volume&page_size=10": emptyResponse,
+		},
+	}
+
+	mockRest := &DummyRest{
+		ctx:     context.Background(),
+		Session: mockSession,
+	}
+
+	mockResource := &mockResourceForIterator{
+		VastResource: &VastResource{
+			resourcePath: "resources",
+			resourceType: "TestResource",
+			Rest:         mockRest,
+		},
+		mockSession: mockSession,
+	}
+
+	// Create iterator with query params
+	iter := NewResourceIterator(context.Background(), mockResource, Params{"name": "vastdb-volume"}, 10)
+
+	// Should return empty RecordSet, not error
+	records, err := iter.Next()
+	if err != nil {
+		t.Fatalf("Expected no error for empty results, got: %v", err)
+	}
+	if len(records) != 0 {
+		t.Errorf("Expected 0 items, got %d", len(records))
+	}
+	if iter.Count() != 0 {
+		t.Errorf("Expected count of 0, got %d", iter.Count())
+	}
+	if iter.HasNext() {
+		t.Error("Expected HasNext to be false when no next field")
+	}
+
+	// Test case 2: Single page with results (no next/previous)
+	singlePageResponse := Record{
+		"count": float64(2),
+		"results": []any{
+			map[string]any{"id": float64(1), "name": "item1"},
+			map[string]any{"id": float64(2), "name": "item2"},
+		},
+	}
+
+	mockSession2 := &mockSessionForIterator{
+		responses: map[string]Renderable{
+			"https://test.example.com:443/api/v1/resources/?page_size=10": singlePageResponse,
+		},
+	}
+
+	mockRest2 := &DummyRest{
+		ctx:     context.Background(),
+		Session: mockSession2,
+	}
+
+	mockResource2 := &mockResourceForIterator{
+		VastResource: &VastResource{
+			resourcePath: "resources",
+			resourceType: "TestResource",
+			Rest:         mockRest2,
+		},
+		mockSession: mockSession2,
+	}
+
+	iter2 := NewResourceIterator(context.Background(), mockResource2, Params{}, 10)
+
+	records, err = iter2.Next()
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+	if len(records) != 2 {
+		t.Errorf("Expected 2 items, got %d", len(records))
+	}
+	if iter2.Count() != 2 {
+		t.Errorf("Expected count of 2, got %d", iter2.Count())
+	}
+	if iter2.HasNext() {
+		t.Error("Expected HasNext to be false when no next field")
+	}
+	if iter2.HasPrevious() {
+		t.Error("Expected HasPrevious to be false when no previous field")
+	}
+}
+
 // Test All() method
 func TestIterator_All(t *testing.T) {
 	// Create mock responses with multiple pages

core/vast_resource.go

@@ -173,10 +173,8 @@ func (e *VastResource) EnsureWithContext(ctx context.Context, searchParams Param
 // GetWithContext retrieves a single resource that matches the given parameters using the provided context.
 // Returns a NotFoundError if no resource is found.
 func (e *VastResource) GetWithContext(ctx context.Context, params Params) (Record, error) {
-	result, err := Request[RecordSet](ctx, e, http.MethodGet, e.resourcePath, params, nil)
-	if !e.resourceOps.has(L) && ExpectStatusCodes(err, http.StatusNotFound) {
-		err.(*ApiError).hints = e.describeResourceFrom(e)
-	}
+	result, err := e.ListWithContext(ctx, params)
+
 	if err != nil {
 		return nil, err
 	}

core/version

@@ -1 +1 @@
-0.104.0
+0.105.0

mkdocs.yml

@@ -25,6 +25,7 @@ nav:
   - Session: session.md
   - Response: response.md
   - Resource Lock: resource-lock.md
+  - Iterators: iterators.md
   - Errors: errors.md
 
 plugins: