From ac189cc5507097f410f7bc7e85735b4a6e9c922d Mon Sep 17 00:00:00 2001
From: Cristian Magherusan-Stanciu <cristi.magherusan@gmail.com>
Date: Tue, 13 Oct 2026 20:52:06 +0200
Subject: [PATCH 1/5] fix(gcp/computeengine): price CUDs per vCPU and GiB from
 the real SKU taxonomy

Match core and RAM SKUs by family label, region and term instead of looking
for the machine type in the description (never present in the live catalog),
multiply by the recommendation's vCPU and GiB, follow every catalog page, and
report commitment, on-demand and savings as consistent term totals.

Refs #92 #245
Closes #271
Closes #321

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../gcp/services/computeengine/client.go      | 151 ++------
 .../gcp/services/computeengine/client_test.go | 232 +------------
 .../gcp/services/computeengine/pricing.go     | 324 ++++++++++++++++++
 .../services/computeengine/pricing_test.go    | 193 +++++++++++
 .../services/computeengine/usage_type_test.go |  43 ---
 5 files changed, 571 insertions(+), 372 deletions(-)
 create mode 100644 providers/gcp/services/computeengine/pricing.go
 create mode 100644 providers/gcp/services/computeengine/pricing_test.go
 delete mode 100644 providers/gcp/services/computeengine/usage_type_test.go

diff --git a/providers/gcp/services/computeengine/client.go b/providers/gcp/services/computeengine/client.go
index 7c3f6167..ab38e456 100644
--- a/providers/gcp/services/computeengine/client.go
+++ b/providers/gcp/services/computeengine/client.go
@@ -12,6 +12,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	compute "cloud.google.com/go/compute/apiv1"
@@ -29,7 +30,6 @@ import (
 
 	"github.com/LeanerCloud/cloud-commitments-go/pkg/common"
 	"github.com/LeanerCloud/cloud-commitments-go/pkg/retry"
-	"github.com/LeanerCloud/cloud-commitments-go/providers/gcp/internal/skumatch"
 )
 
 // maxRecsPages caps GCP Recommender API iteration to avoid burning a Lambda
@@ -267,6 +267,9 @@ type Client struct {
 	machineTypesService MachineTypesService
 	billingService      BillingService
 	recommenderClient   RecommenderClient
+
+	skuMu    sync.Mutex
+	skuCache []*cloudbilling.Sku
 }
 
 // NewClient creates a new GCP Compute Engine client.
@@ -292,6 +295,9 @@ func (c *Client) SetMachineTypesService(svc MachineTypesService) {
 // SetBillingService sets the billing service (for testing).
 func (c *Client) SetBillingService(svc BillingService) {
 	c.billingService = svc
+	c.skuMu.Lock()
+	c.skuCache = nil
+	c.skuMu.Unlock()
 }
 
 // SetRecommenderClient sets the recommender client (for testing).
@@ -335,11 +341,27 @@ func (r *realMachineTypesService) Close() error {
 
 // realBillingService wraps the real cloudbilling.APIService.
 type realBillingService struct {
+	ctx     context.Context
 	service *cloudbilling.APIService
 }
 
+// ListSKUs returns every SKU of the service. The catalog is paged (5000 SKUs per
+// page, 33k for Compute Engine), so all pages are followed.
 func (r *realBillingService) ListSKUs(serviceID string) (*cloudbilling.ListSkusResponse, error) {
-	return r.service.Services.Skus.List(serviceID).Do()
+	all := &cloudbilling.ListSkusResponse{}
+	pages := 0
+	err := r.service.Services.Skus.List(serviceID).PageSize(skuPageSize).Pages(r.ctx, func(page *cloudbilling.ListSkusResponse) error {
+		pages++
+		if pages > maxSKUPages {
+			return fmt.Errorf("computeengine: billing SKU listing page cap (%d pages) reached", maxSKUPages)
+		}
+		all.Skus = append(all.Skus, page.Skus...)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return all, nil
 }
 
 // realRecommenderIterator wraps the real recommender iterator.
@@ -960,7 +982,11 @@ func (c *Client) GetOfferingDetails(ctx context.Context, rec common.Recommendati
 		termYears = 3
 	}
 
-	pricing, err := c.getComputePricing(ctx, rec.ResourceType, c.region, termYears)
+	res, err := resourcesFromRecommendation(rec)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get pricing: %w", err)
+	}
+	pricing, err := c.getComputePricing(ctx, rec.ResourceType, c.region, termYears, res)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get pricing: %w", err)
 	}
@@ -1042,52 +1068,6 @@ func (c *Client) GetValidResourceTypes(ctx context.Context) ([]string, error) {
 	return machineTypes, nil
 }
 
-// ComputePricing contains pricing information for Compute Engine.
-type ComputePricing struct {
-	HourlyRate        float64
-	CommitmentPrice   float64
-	OnDemandPrice     float64
-	Currency          string
-	SavingsPercentage float64
-}
-
-// getComputePricing gets pricing from GCP Cloud Billing Catalog API.
-// It returns an error when commitment pricing is absent from the catalog rather
-// than fabricating a price from a hardcoded discount factor (issue #1020).
-func (c *Client) getComputePricing(ctx context.Context, machineType, region string, termYears int) (*ComputePricing, error) {
-	svc, err := c.getOrCreateBillingService(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	skus, err := svc.ListSKUs("services/6F81-5844-456A")
-	if err != nil {
-		return nil, fmt.Errorf("failed to list SKUs: %w", err)
-	}
-
-	onDemandPrice, commitmentPrice, currency, err := extractComputePricingFromSKUs(skus.Skus, machineType, region)
-	if err != nil {
-		return nil, err
-	}
-	if onDemandPrice == 0 {
-		return nil, fmt.Errorf("no on-demand pricing found for machine type %s", machineType)
-	}
-	if commitmentPrice == 0 {
-		return nil, fmt.Errorf("no commitment pricing found for machine type %s in region %s: catalog has no CUD SKU; cannot compute savings percentage", machineType, region)
-	}
-
-	hoursInTerm := 8760.0 * float64(termYears)
-	savingsPercentage := calculateComputeSavingsPercentage(onDemandPrice, hoursInTerm, commitmentPrice)
-
-	return &ComputePricing{
-		HourlyRate:        commitmentPrice / hoursInTerm,
-		CommitmentPrice:   commitmentPrice,
-		OnDemandPrice:     onDemandPrice * hoursInTerm,
-		Currency:          currency,
-		SavingsPercentage: savingsPercentage,
-	}, nil
-}
-
 // getOrCreateBillingService returns the billing service, creating it if needed.
 func (c *Client) getOrCreateBillingService(ctx context.Context) (BillingService, error) {
 	if c.billingService != nil {
@@ -1099,71 +1079,7 @@ func (c *Client) getOrCreateBillingService(ctx context.Context) (BillingService,
 		return nil, fmt.Errorf("failed to create billing service: %w", err)
 	}
 
-	return &realBillingService{service: service}, nil
-}
-
-// extractComputePricingFromSKUs extracts on-demand and commitment pricing from SKU list.
-func extractComputePricingFromSKUs(skus []*cloudbilling.Sku, machineType, region string) (onDemand, commitment float64, currency string, err error) {
-	currency = "USD"
-
-	for _, sku := range skus {
-		if !skuMatchesMachineType(sku, machineType, region) {
-			continue
-		}
-
-		price, curr := extractComputePriceFromSKU(sku)
-		if price == 0 {
-			continue
-		}
-
-		if curr != "" {
-			currency = curr
-		}
-
-		slot, slotErr := skumatch.Slot(sku)
-		if slotErr != nil {
-			return 0, 0, "", slotErr
-		}
-		switch slot {
-		case skumatch.SlotCommitment:
-			commitment = price
-		case skumatch.SlotOnDemand:
-			onDemand = price
-		}
-	}
-
-	return onDemand, commitment, currency, nil
-}
-
-// extractComputePriceFromSKU extracts the unit price from a SKU.
-func extractComputePriceFromSKU(sku *cloudbilling.Sku) (price float64, currency string) {
-	if len(sku.PricingInfo) == 0 {
-		return 0, ""
-	}
-
-	pricingInfo := sku.PricingInfo[0]
-	if pricingInfo.PricingExpression == nil || len(pricingInfo.PricingExpression.TieredRates) == 0 {
-		return 0, ""
-	}
-
-	rate := pricingInfo.PricingExpression.TieredRates[0]
-	if rate.UnitPrice == nil {
-		return 0, ""
-	}
-
-	price = float64(rate.UnitPrice.Units) + float64(rate.UnitPrice.Nanos)/1e9
-	return price, rate.UnitPrice.CurrencyCode
-}
-
-// calculateComputeSavingsPercentage calculates the savings percentage.
-func calculateComputeSavingsPercentage(onDemandPrice, hoursInTerm, commitmentPrice float64) float64 {
-	onDemandTotal := onDemandPrice * hoursInTerm
-	return ((onDemandTotal - commitmentPrice) / onDemandTotal) * 100
-}
-
-// skuMatchesMachineType checks if a SKU matches the machine type and region.
-func skuMatchesMachineType(sku *cloudbilling.Sku, machineType, region string) bool {
-	return skumatch.HasToken(sku.Description, machineType) && skumatch.InRegion(sku, region)
+	return &realBillingService{ctx: ctx, service: service}, nil
 }
 
 // convertGCPRecommendation converts a GCP Recommender recommendation to common format.
@@ -1245,7 +1161,12 @@ func (c *Client) enrichRecWithPricing(ctx context.Context, rec *common.Recommend
 		return
 	}
 	termYears := termYearsFromTerm(rec.Term)
-	pricing, err := c.getComputePricing(ctx, rec.ResourceType, c.region, termYears)
+	res, err := resourcesFromRecommendation(*rec)
+	if err != nil {
+		log.Printf("computeengine: pricing unavailable for %s in %s: %v", rec.ResourceType, c.region, err)
+		return
+	}
+	pricing, err := c.getComputePricing(ctx, rec.ResourceType, c.region, termYears, res)
 	if err != nil {
 		log.Printf("computeengine: pricing unavailable for %s in %s (issue #1020): %v", rec.ResourceType, c.region, err)
 		return
diff --git a/providers/gcp/services/computeengine/client_test.go b/providers/gcp/services/computeengine/client_test.go
index 304274a2..e91ddc58 100644
--- a/providers/gcp/services/computeengine/client_test.go
+++ b/providers/gcp/services/computeengine/client_test.go
@@ -345,90 +345,6 @@ func TestComputeEngineClient_GetRegion(t *testing.T) {
 	}
 }
 
-func TestSkuMatchesMachineType(t *testing.T) {
-	tests := []struct {
-		name        string
-		sku         *cloudbilling.Sku
-		machineType string
-		region      string
-		expected    bool
-	}{
-		{
-			name: "SKU matches machine type and region",
-			sku: &cloudbilling.Sku{
-				Description:    "n1-standard-1 VM running in Americas",
-				Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-				ServiceRegions: []string{"us-central1"},
-			},
-			machineType: "n1-standard-1",
-			region:      "us-central1",
-			expected:    true,
-		},
-		{
-			name: "SKU matches machine type but not region",
-			sku: &cloudbilling.Sku{
-				Description:    "n1-standard-1 VM running in Europe",
-				Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-				ServiceRegions: []string{"europe-west1"},
-			},
-			machineType: "n1-standard-1",
-			region:      "us-central1",
-			expected:    false,
-		},
-		{
-			name: "SKU does not match machine type",
-			sku: &cloudbilling.Sku{
-				Description:    "n2-highmem-4 VM running in Americas",
-				Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-				ServiceRegions: []string{"us-central1"},
-			},
-			machineType: "n1-standard-1",
-			region:      "us-central1",
-			expected:    false,
-		},
-		{
-			name: "SKU with nil service regions matches no region",
-			sku: &cloudbilling.Sku{
-				Description:    "n1-standard-1 VM",
-				Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-				ServiceRegions: nil,
-			},
-			machineType: "n1-standard-1",
-			region:      "us-central1",
-			expected:    false,
-		},
-		{
-			name: "SKU for a longer machine type that starts with the same text is a decoy",
-			sku: &cloudbilling.Sku{
-				Description:    "n1-standard-16 VM running in Americas",
-				Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-				ServiceRegions: []string{"us-central1"},
-			},
-			machineType: "n1-standard-1",
-			region:      "us-central1",
-			expected:    false,
-		},
-		{
-			name: "Case insensitive machine type match",
-			sku: &cloudbilling.Sku{
-				Description:    "N1-STANDARD-1 VM running in Americas",
-				Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-				ServiceRegions: []string{"us-central1"},
-			},
-			machineType: "n1-standard-1",
-			region:      "us-central1",
-			expected:    true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := skuMatchesMachineType(tt.sku, tt.machineType, tt.region)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
 func TestComputePricingStructure(t *testing.T) {
 	pricing := ComputePricing{
 		HourlyRate:        0.10,
@@ -1076,69 +992,24 @@ func TestComputeEngineClient_PurchaseCommitment_WaitError(t *testing.T) {
 func TestComputeEngineClient_GetOfferingDetails_WithMock(t *testing.T) {
 	ctx := context.Background()
 	client, _ := NewClient(ctx, "test-project", "us-central1")
-
-	// Both on-demand and commitment SKUs are required; without a commitment SKU
-	// getComputePricing now returns an error (issue #1020 fix).
-	mockService := &MockBillingService{
-		skus: &cloudbilling.ListSkusResponse{
-			Skus: []*cloudbilling.Sku{
-				{
-					Description:    "n1-standard-1 VM running in Americas",
-					Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-					ServiceRegions: []string{"us-central1"},
-					PricingInfo: []*cloudbilling.PricingInfo{
-						{
-							PricingExpression: &cloudbilling.PricingExpression{
-								TieredRates: []*cloudbilling.TierRate{
-									{
-										UnitPrice: &cloudbilling.Money{
-											Units:        0,
-											Nanos:        50000000,
-											CurrencyCode: "USD",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-				{
-					Description:    "n1-standard-1 commitment 1yr in Americas",
-					Category:       &cloudbilling.Category{UsageType: "Commit1Yr"},
-					ServiceRegions: []string{"us-central1"},
-					PricingInfo: []*cloudbilling.PricingInfo{
-						{
-							PricingExpression: &cloudbilling.PricingExpression{
-								TieredRates: []*cloudbilling.TierRate{
-									{
-										UnitPrice: &cloudbilling.Money{
-											Units:        0,
-											Nanos:        32000000,
-											CurrencyCode: "USD",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-	client.SetBillingService(mockService)
+	client.SetBillingService(mockBillingWithCommitment())
 
 	rec := common.Recommendation{
-		ResourceType:  "n1-standard-1",
+		ResourceType:  "n1-standard-4",
 		Term:          "1yr",
-		PaymentOption: "upfront",
+		PaymentOption: "monthly",
+		Count:         4,
+		Details:       common.ComputeDetails{MemoryGB: 15},
 	}
 
 	details, err := client.GetOfferingDetails(ctx, rec)
 	require.NoError(t, err)
-	assert.Equal(t, "n1-standard-1", details.ResourceType)
+	assert.Equal(t, "n1-standard-4", details.ResourceType)
 	assert.Equal(t, "1yr", details.Term)
 	assert.Equal(t, "USD", details.Currency)
-	assert.Greater(t, details.TotalCost, float64(0))
+	// (4 vCPU * 0.019915 + 15 GiB * 0.002669) per hour over 8760 h.
+	assert.InDelta(t, (4*0.019915+15*0.002669)*8760, details.TotalCost, 1e-6)
+	assert.InDelta(t, details.TotalCost/12, details.RecurringCost, 1e-6)
 }
 
 func TestComputeEngineClient_GetOfferingDetails_NoPricing(t *testing.T) {
@@ -1152,11 +1023,11 @@ func TestComputeEngineClient_GetOfferingDetails_NoPricing(t *testing.T) {
 	}
 	client.SetBillingService(mockService)
 
-	rec := common.Recommendation{ResourceType: "n1-standard-1"}
+	rec := common.Recommendation{ResourceType: "n1-standard-1", Count: 1, Details: common.ComputeDetails{MemoryGB: 3.75}}
 
 	_, err := client.GetOfferingDetails(ctx, rec)
 	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "no on-demand pricing found")
+	assert.Contains(t, err.Error(), "no on-demand core and RAM pricing found")
 }
 
 func TestComputeEngineClient_GetRecommendations_WithMock(t *testing.T) {
@@ -1392,55 +1263,11 @@ func realisticCUDRecommendation() *recommenderpb.Recommendation {
 	}
 }
 
-// mockBillingWithCommitment returns a MockBillingService that has both an
-// on-demand SKU and a commitment SKU for n1-standard machines in us-central1.
+// mockBillingWithCommitment returns the live-catalog-shaped N1 core and RAM SKUs
+// (on demand and 1-year commitment, us-central1) that the n1-standard-4 fixtures
+// are priced against.
 func mockBillingWithCommitment() *MockBillingService {
-	return &MockBillingService{
-		skus: &cloudbilling.ListSkusResponse{
-			Skus: []*cloudbilling.Sku{
-				{
-					Description:    "n1-standard-4 VM running in Americas",
-					Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-					ServiceRegions: []string{"us-central1"},
-					PricingInfo: []*cloudbilling.PricingInfo{
-						{
-							PricingExpression: &cloudbilling.PricingExpression{
-								TieredRates: []*cloudbilling.TierRate{
-									{
-										UnitPrice: &cloudbilling.Money{
-											Units:        0,
-											Nanos:        190000000,
-											CurrencyCode: "USD",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-				{
-					Description:    "n1-standard-4 commitment 1yr in Americas",
-					Category:       &cloudbilling.Category{UsageType: "Commit1Yr"},
-					ServiceRegions: []string{"us-central1"},
-					PricingInfo: []*cloudbilling.PricingInfo{
-						{
-							PricingExpression: &cloudbilling.PricingExpression{
-								TieredRates: []*cloudbilling.TierRate{
-									{
-										UnitPrice: &cloudbilling.Money{
-											Units:        0,
-											Nanos:        120000000,
-											CurrencyCode: "USD",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
+	return &MockBillingService{skus: &cloudbilling.ListSkusResponse{Skus: n1Americas1YrSKUs()}}
 }
 
 // TestConverterToInsert_CountNonZero_VCPUAmountSet is the primary regression test
@@ -1567,35 +1394,12 @@ func TestGetComputePricing_NoCommitmentSKUReturnsError(t *testing.T) {
 	ctx := context.Background()
 	client, _ := NewClient(ctx, "test-project", "us-central1")
 
-	// Only on-demand SKU -- no commitment SKU.
+	// Only the on-demand SKUs -- no commitment SKU.
 	client.SetBillingService(&MockBillingService{
-		skus: &cloudbilling.ListSkusResponse{
-			Skus: []*cloudbilling.Sku{
-				{
-					Description:    "n1-standard-4 VM running in Americas",
-					Category:       &cloudbilling.Category{UsageType: "OnDemand"},
-					ServiceRegions: []string{"us-central1"},
-					PricingInfo: []*cloudbilling.PricingInfo{
-						{
-							PricingExpression: &cloudbilling.PricingExpression{
-								TieredRates: []*cloudbilling.TierRate{
-									{
-										UnitPrice: &cloudbilling.Money{
-											Units:        0,
-											Nanos:        190000000,
-											CurrencyCode: "USD",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
+		skus: &cloudbilling.ListSkusResponse{Skus: n1Americas1YrSKUs()[:2]},
 	})
 
-	pricing, err := client.getComputePricing(ctx, "n1-standard-4", "us-central1", 1)
+	pricing, err := client.getComputePricing(ctx, "n1-standard-4", "us-central1", 1, computeResources{vcpus: 4, memoryGiB: 15})
 	require.Error(t, err, "getComputePricing must return an error when no commitment SKU exists (issue #1020)")
 	assert.Contains(t, err.Error(), "no commitment pricing found")
 	assert.Nil(t, pricing, "no pricing struct must be returned when commitment SKU is missing")
diff --git a/providers/gcp/services/computeengine/pricing.go b/providers/gcp/services/computeengine/pricing.go
new file mode 100644
index 00000000..a6cc14a4
--- /dev/null
+++ b/providers/gcp/services/computeengine/pricing.go
@@ -0,0 +1,324 @@
+package computeengine
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"google.golang.org/api/cloudbilling/v1"
+
+	"github.com/LeanerCloud/cloud-commitments-go/pkg/common"
+	"github.com/LeanerCloud/cloud-commitments-go/providers/gcp/internal/skumatch"
+)
+
+const (
+	// computeServiceID is the Cloud Billing catalog service for Compute Engine.
+	computeServiceID = "services/6F81-5844-456A"
+
+	// skuPageSize is the largest page the catalog serves.
+	skuPageSize = 5000
+
+	// maxSKUPages caps catalog paging; Compute Engine is about 7 pages.
+	maxSKUPages = 50
+
+	hoursPerYear = 8760.0
+
+	usageUnitHour    = "h"
+	usageUnitGiBHour = "GiBy.h"
+
+	usageTypeCommit1Yr = "Commit1Yr"
+	usageTypeCommit3Yr = "Commit3Yr"
+)
+
+// ComputePricing is the price of a commitment's resources, for one term.
+type ComputePricing struct {
+	// HourlyRate is the committed price per hour for the whole resource set.
+	HourlyRate float64
+	// CommitmentPrice is the committed price over the whole term.
+	CommitmentPrice float64
+	// OnDemandPrice is the on-demand price of the same resources over the term.
+	OnDemandPrice     float64
+	Currency          string
+	SavingsPercentage float64
+}
+
+// computeResources is the amount a commitment covers.
+type computeResources struct {
+	vcpus     int
+	memoryGiB float64
+}
+
+// resourcesFromRecommendation reads the vCPU count and memory a recommendation
+// covers; both are required to price it.
+func resourcesFromRecommendation(rec common.Recommendation) (computeResources, error) {
+	if rec.Count <= 0 {
+		return computeResources{}, fmt.Errorf("recommendation for %s has no vCPU count; cannot price it", rec.ResourceType)
+	}
+	memMB, err := memoryMBFromDetails(rec)
+	if err != nil {
+		return computeResources{}, err
+	}
+	return computeResources{vcpus: rec.Count, memoryGiB: float64(memMB) / 1024.0}, nil
+}
+
+// skuFamilyLabels holds how the catalog names a machine family. The labels are
+// not derivable from the machine type prefix for every family.
+type skuFamilyLabels struct {
+	onDemand string   // "<label> Instance Core running in ..."
+	commit   []string // "Commitment v1: <label> Cpu in ..."
+}
+
+// skuFamilyOverrides lists families whose catalog label differs from the
+// upper-cased machine type prefix. Verified against the live catalog.
+var skuFamilyOverrides = map[string]skuFamilyLabels{
+	"n1":  {onDemand: "N1", commit: []string{"N1", ""}}, // older regions omit the family
+	"n2d": {onDemand: "N2D AMD", commit: []string{"N2D AMD"}},
+	"c2d": {onDemand: "C2D AMD", commit: []string{"C2D AMD"}},
+	"t2d": {onDemand: "T2D AMD", commit: []string{"T2D AMD"}},
+	"c4a": {onDemand: "C4A Arm", commit: []string{"C4A Arm"}},
+	"c2":  {onDemand: "Compute optimized", commit: []string{"Compute optimized"}},
+	"m1":  {onDemand: "Memory-optimized", commit: []string{"Memory-optimized"}},
+	"m2":  {onDemand: "Memory-optimized", commit: []string{"Memory-optimized"}},
+	"m3":  {onDemand: "M3 Memory-optimized", commit: []string{"M3 Memory-optimized"}},
+}
+
+func familyLabels(machineType string) (skuFamilyLabels, error) {
+	family, _, _ := strings.Cut(strings.ToLower(strings.TrimSpace(machineType)), "-")
+	if family == "" {
+		return skuFamilyLabels{}, fmt.Errorf("no machine family in machine type %q", machineType)
+	}
+	if labels, ok := skuFamilyOverrides[family]; ok {
+		return labels, nil
+	}
+	label := strings.ToUpper(family)
+	return skuFamilyLabels{onDemand: label, commit: []string{label}}, nil
+}
+
+// skuRates is the per-vCPU-hour and per-GiB-hour price of one family.
+type skuRates struct {
+	cpu, ram float64
+}
+
+type familyRates struct {
+	onDemand, commitment skuRates
+	currency             string
+}
+
+// onDemandDescription matches e.g. "N2 Instance Core running in Americas",
+// "N1 Predefined Instance Ram running in Americas" and "Compute optimized Core
+// running in Americas". Sole-tenancy, custom, DWS, reserved and spot SKUs carry
+// extra words in front of the family and so do not match.
+func onDemandDescription(label string) *regexp.Regexp {
+	return regexp.MustCompile(`^` + regexp.QuoteMeta(label) + `(?: Predefined)?(?: Instance)? (Core|Ram) running in `)
+}
+
+// commitmentDescription matches e.g. "Commitment v1: N2 Cpu in Americas for 1 Year".
+func commitmentDescription(label string) *regexp.Regexp {
+	family := regexp.QuoteMeta(label) + " "
+	if label == "" {
+		family = ""
+	}
+	return regexp.MustCompile(`^Commitment v1: ` + family + `(Cpu|Ram) in .* for (1|3) Years?$`)
+}
+
+// rateMatcher recognises the catalog SKUs of one family, region and term.
+type rateMatcher struct {
+	region      string
+	onDemand    *regexp.Regexp
+	commitments []*regexp.Regexp
+	wantTerm    string
+	wantUsage   string
+}
+
+func newRateMatcher(labels skuFamilyLabels, region string, termYears int) rateMatcher {
+	m := rateMatcher{region: region, onDemand: onDemandDescription(labels.onDemand), wantTerm: "1", wantUsage: usageTypeCommit1Yr}
+	if termYears == 3 {
+		m.wantTerm, m.wantUsage = "3", usageTypeCommit3Yr
+	}
+	for _, label := range labels.commit {
+		m.commitments = append(m.commitments, commitmentDescription(label))
+	}
+	return m
+}
+
+// classify says whether the SKU is one of the four prices wanted, and which.
+// matched is false for every other SKU in the catalog.
+func (m rateMatcher) classify(sku *cloudbilling.Sku) (isCommit, isRAM, matched bool, err error) {
+	if sku.Category == nil || sku.Category.ResourceFamily != "Compute" || !skumatch.InRegion(sku, m.region) {
+		return false, false, false, nil
+	}
+	if sku.Category.UsageType == "OnDemand" {
+		sub := m.onDemand.FindStringSubmatch(sku.Description)
+		if sub == nil {
+			return false, false, false, nil
+		}
+		return false, sub[1] == "Ram", true, nil
+	}
+	for _, re := range m.commitments {
+		sub := re.FindStringSubmatch(sku.Description)
+		if sub == nil || sub[2] != m.wantTerm {
+			continue
+		}
+		if sku.Category.UsageType != m.wantUsage {
+			return false, false, false, fmt.Errorf("SKU %s (%q) has usage type %q, expected %q", sku.SkuId, sku.Description, sku.Category.UsageType, m.wantUsage)
+		}
+		return true, sub[1] == "Ram", true, nil
+	}
+	return false, false, false, nil
+}
+
+// rateSlot is one price being collected.
+type rateSlot struct {
+	value float64
+	seen  bool
+}
+
+func (r *rateSlot) set(price float64, sku *cloudbilling.Sku) error {
+	if r.seen && r.value != price {
+		return fmt.Errorf("ambiguous catalog: SKU %s (%q) prices %v but another matching SKU prices %v", sku.SkuId, sku.Description, price, r.value)
+	}
+	r.value, r.seen = price, true
+	return nil
+}
+
+// rateCollector accumulates the four prices wanted from matched SKUs.
+type rateCollector struct {
+	odCPU, odRAM, cCPU, cRAM rateSlot
+	currency                 string
+}
+
+func (c *rateCollector) add(sku *cloudbilling.Sku, isCommit, isRAM bool) error {
+	price, currency, unit, err := skuUnitPrice(sku)
+	if err != nil {
+		return err
+	}
+	wantUnit := usageUnitHour
+	if isRAM {
+		wantUnit = usageUnitGiBHour
+	}
+	if unit != wantUnit {
+		return fmt.Errorf("SKU %s (%q) is priced per %q, expected %q", sku.SkuId, sku.Description, unit, wantUnit)
+	}
+	if c.currency != "" && c.currency != currency {
+		return fmt.Errorf("SKU %s (%q) is in %s but other matching SKUs are in %s", sku.SkuId, sku.Description, currency, c.currency)
+	}
+	c.currency = currency
+
+	slot := &c.odCPU
+	switch {
+	case isCommit && isRAM:
+		slot = &c.cRAM
+	case isCommit:
+		slot = &c.cCPU
+	case isRAM:
+		slot = &c.odRAM
+	}
+	return slot.set(price, sku)
+}
+
+func (c *rateCollector) rates(machineType, region string, termYears int) (*familyRates, error) {
+	switch {
+	case !c.odCPU.seen || !c.odRAM.seen:
+		return nil, fmt.Errorf("no on-demand core and RAM pricing found for machine family of %s in %s", machineType, region)
+	case !c.cCPU.seen || !c.cRAM.seen:
+		return nil, fmt.Errorf("no commitment pricing found for machine type %s in region %s: catalog has no %d-year CUD core and RAM SKU for the family; cannot compute savings percentage", machineType, region, termYears)
+	}
+	return &familyRates{
+		onDemand:   skuRates{cpu: c.odCPU.value, ram: c.odRAM.value},
+		commitment: skuRates{cpu: c.cCPU.value, ram: c.cRAM.value},
+		currency:   c.currency,
+	}, nil
+}
+
+// findFamilyRates selects the on-demand and commitment CPU and RAM rates for the
+// machine family, region and term out of the Compute Engine catalog.
+func findFamilyRates(skus []*cloudbilling.Sku, machineType, region string, termYears int) (*familyRates, error) {
+	labels, err := familyLabels(machineType)
+	if err != nil {
+		return nil, err
+	}
+	matcher := newRateMatcher(labels, region, termYears)
+
+	var collector rateCollector
+	for _, sku := range skus {
+		isCommit, isRAM, matched, err := matcher.classify(sku)
+		if err != nil {
+			return nil, err
+		}
+		if !matched {
+			continue
+		}
+		if err := collector.add(sku, isCommit, isRAM); err != nil {
+			return nil, err
+		}
+	}
+	return collector.rates(machineType, region, termYears)
+}
+
+// skuUnitPrice returns the first tier's unit price, currency and usage unit.
+func skuUnitPrice(sku *cloudbilling.Sku) (price float64, currency, unit string, err error) {
+	if len(sku.PricingInfo) == 0 || sku.PricingInfo[0].PricingExpression == nil {
+		return 0, "", "", fmt.Errorf("SKU %s (%q) has no pricing", sku.SkuId, sku.Description)
+	}
+	expr := sku.PricingInfo[0].PricingExpression
+	if len(expr.TieredRates) == 0 || expr.TieredRates[0].UnitPrice == nil {
+		return 0, "", "", fmt.Errorf("SKU %s (%q) has no unit price", sku.SkuId, sku.Description)
+	}
+	money := expr.TieredRates[0].UnitPrice
+	price = float64(money.Units) + float64(money.Nanos)/1e9
+	if price <= 0 {
+		return 0, "", "", fmt.Errorf("SKU %s (%q) has non-positive price %v", sku.SkuId, sku.Description, price)
+	}
+	if money.CurrencyCode == "" {
+		return 0, "", "", fmt.Errorf("SKU %s (%q) has no currency", sku.SkuId, sku.Description)
+	}
+	return price, money.CurrencyCode, expr.UsageUnit, nil
+}
+
+// getComputePricing prices a commitment for res over the term from the Cloud
+// Billing catalog: vCPUs times the family core rate plus GiB times the family RAM
+// rate, for both the commitment and on demand. It errors when the catalog has no
+// commitment price rather than fabricating one.
+func (c *Client) getComputePricing(ctx context.Context, machineType, region string, termYears int, res computeResources) (*ComputePricing, error) {
+	skus, err := c.listComputeSKUs(ctx)
+	if err != nil {
+		return nil, err
+	}
+	rates, err := findFamilyRates(skus, machineType, region, termYears)
+	if err != nil {
+		return nil, err
+	}
+
+	hours := hoursPerYear * float64(termYears)
+	commitHourly := float64(res.vcpus)*rates.commitment.cpu + res.memoryGiB*rates.commitment.ram
+	onDemandHourly := float64(res.vcpus)*rates.onDemand.cpu + res.memoryGiB*rates.onDemand.ram
+
+	return &ComputePricing{
+		HourlyRate:        commitHourly,
+		CommitmentPrice:   commitHourly * hours,
+		OnDemandPrice:     onDemandHourly * hours,
+		Currency:          rates.currency,
+		SavingsPercentage: (onDemandHourly - commitHourly) / onDemandHourly * 100,
+	}, nil
+}
+
+// listComputeSKUs returns the Compute Engine catalog, fetched once per client:
+// it is 33k SKUs over several pages and every recommendation prices against it.
+func (c *Client) listComputeSKUs(ctx context.Context) ([]*cloudbilling.Sku, error) {
+	c.skuMu.Lock()
+	defer c.skuMu.Unlock()
+	if c.skuCache != nil {
+		return c.skuCache, nil
+	}
+	svc, err := c.getOrCreateBillingService(ctx)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := svc.ListSKUs(computeServiceID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list SKUs: %w", err)
+	}
+	c.skuCache = resp.Skus
+	return c.skuCache, nil
+}
diff --git a/providers/gcp/services/computeengine/pricing_test.go b/providers/gcp/services/computeengine/pricing_test.go
new file mode 100644
index 00000000..d2369799
--- /dev/null
+++ b/providers/gcp/services/computeengine/pricing_test.go
@@ -0,0 +1,193 @@
+package computeengine
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/api/cloudbilling/v1"
+	"google.golang.org/api/option"
+
+	"github.com/LeanerCloud/cloud-commitments-go/pkg/common"
+)
+
+func newRec(machineType string, vcpus int, memGB float64) common.Recommendation {
+	return common.Recommendation{ResourceType: machineType, Count: vcpus, Details: common.ComputeDetails{MemoryGB: memGB}}
+}
+
+var americas = []string{"us-central1", "us-east1", "us-west1"}
+
+// catalogSKU builds a SKU shaped like the live Cloud Billing catalog entries
+// (services/6F81-5844-456A, fetched 2026-10-13); descriptions, groups, units
+// and prices are copied from real SKUs.
+func catalogSKU(id, description, group, usageType, unit string, nanos int64, regions []string) *cloudbilling.Sku {
+	return &cloudbilling.Sku{
+		SkuId:          id,
+		Description:    description,
+		Category:       &cloudbilling.Category{ResourceFamily: "Compute", ResourceGroup: group, UsageType: usageType},
+		ServiceRegions: regions,
+		PricingInfo: []*cloudbilling.PricingInfo{{PricingExpression: &cloudbilling.PricingExpression{
+			UsageUnit:   unit,
+			TieredRates: []*cloudbilling.TierRate{{UnitPrice: &cloudbilling.Money{CurrencyCode: "USD", Nanos: nanos}}},
+		}}},
+	}
+}
+
+// n1Americas1YrSKUs: N1 on-demand core and RAM, then 1-year commitment core and RAM.
+func n1Americas1YrSKUs() []*cloudbilling.Sku {
+	return []*cloudbilling.Sku{
+		catalogSKU("2E27-4F75-95CD", "N1 Predefined Instance Core running in Americas", "N1Standard", "OnDemand", "h", 31611000, americas),
+		catalogSKU("6C71-E844-38BC", "N1 Predefined Instance Ram running in Americas", "N1Standard", "OnDemand", "GiBy.h", 4237000, americas),
+		catalogSKU("6FDA-DB41-BB57", "Commitment v1: Cpu in Americas for 1 Year", "CPU", "Commit1Yr", "h", 19915000, americas),
+		catalogSKU("E35D-222F-E443", "Commitment v1: Ram in Americas for 1 Year", "RAM", "Commit1Yr", "GiBy.h", 2669000, americas),
+	}
+}
+
+// n2AmericasSKUs: live N2 SKUs for us-central1 (Americas), plus decoys the real
+// catalog carries next to them.
+func n2AmericasSKUs() []*cloudbilling.Sku {
+	return []*cloudbilling.Sku{
+		catalogSKU("n2-od-core", "N2 Instance Core running in Americas", "CPU", "OnDemand", "h", 31611000, americas),
+		catalogSKU("n2-od-ram", "N2 Instance Ram running in Americas", "RAM", "OnDemand", "GiBy.h", 4237000, americas),
+		catalogSKU("n2-c1-core", "Commitment v1: N2 Cpu in Americas for 1 Year", "CPU", "Commit1Yr", "h", 19915000, americas),
+		catalogSKU("n2-c1-ram", "Commitment v1: N2 Ram in Americas for 1 Year", "RAM", "Commit1Yr", "GiBy.h", 2669000, americas),
+		catalogSKU("n2-c3-core", "Commitment v1: N2 Cpu in Americas for 3 Year", "CPU", "Commit3Yr", "h", 14225000, americas),
+		catalogSKU("n2-c3-ram", "Commitment v1: N2 Ram in Americas for 3 Year", "RAM", "Commit3Yr", "GiBy.h", 1907000, americas),
+		// Same family name prefix, different product: must not be read as N2.
+		catalogSKU("n2d-od-core", "N2D AMD Instance Core running in Americas", "CPU", "OnDemand", "h", 27502000, americas),
+		catalogSKU("n2-custom-core", "N2 Custom Instance Core running in Americas", "CPU", "OnDemand", "h", 33000000, americas),
+		catalogSKU("n2-sole-core", "Sole Tenancy Premium for N2 Sole Tenancy Instance Core running in Americas", "CPU", "OnDemand", "h", 1000000, americas),
+		// Other region.
+		catalogSKU("n2-od-core-eu", "N2 Instance Core running in Frankfurt", "CPU", "OnDemand", "h", 99000000, []string{"europe-west3"}),
+	}
+}
+
+// Live catalog check, n2-standard-8 in us-central1 (8 vCPU, 32 GiB), 1 year:
+//
+//	on demand  8*0.031611 + 32*0.004237 = 0.388472 USD/h
+//	commitment 8*0.019915 + 32*0.002669 = 0.244728 USD/h  (37.0% off)
+func TestGetComputePricing_N2StandardFromLiveShapedCatalog(t *testing.T) {
+	ctx := context.Background()
+	client, _ := NewClient(ctx, "p", "us-central1")
+	client.SetBillingService(&MockBillingService{skus: &cloudbilling.ListSkusResponse{Skus: n2AmericasSKUs()}})
+	res := computeResources{vcpus: 8, memoryGiB: 32}
+
+	one, err := client.getComputePricing(ctx, "n2-standard-8", "us-central1", 1, res)
+	require.NoError(t, err)
+	assert.Equal(t, "USD", one.Currency)
+	assert.InDelta(t, 0.244728, one.HourlyRate, 1e-9)
+	assert.InDelta(t, 0.244728*8760, one.CommitmentPrice, 1e-6)
+	assert.InDelta(t, 0.388472*8760, one.OnDemandPrice, 1e-6)
+	assert.InDelta(t, 37.0, one.SavingsPercentage, 0.05)
+
+	three, err := client.getComputePricing(ctx, "n2-standard-8", "us-central1", 3, res)
+	require.NoError(t, err)
+	assert.InDelta(t, (8*0.014225+32*0.001907)*8760*3, three.CommitmentPrice, 1e-6)
+	assert.InDelta(t, 0.388472*8760*3, three.OnDemandPrice, 1e-6)
+	assert.Greater(t, three.SavingsPercentage, one.SavingsPercentage)
+}
+
+func TestFindFamilyRates_ErrorsAreLoud(t *testing.T) {
+	t.Run("region without SKUs", func(t *testing.T) {
+		_, err := findFamilyRates(n2AmericasSKUs(), "n2-standard-8", "asia-east1", 1)
+		require.ErrorContains(t, err, "no on-demand core and RAM pricing")
+	})
+	t.Run("family without commitment SKUs", func(t *testing.T) {
+		_, err := findFamilyRates(n2AmericasSKUs()[:2], "n2-standard-8", "us-central1", 1)
+		require.ErrorContains(t, err, "no commitment pricing")
+	})
+	t.Run("unit mismatch", func(t *testing.T) {
+		skus := n2AmericasSKUs()
+		skus[0].PricingInfo[0].PricingExpression.UsageUnit = "mo"
+		_, err := findFamilyRates(skus, "n2-standard-8", "us-central1", 1)
+		require.ErrorContains(t, err, "expected \"h\"")
+	})
+	t.Run("conflicting duplicate", func(t *testing.T) {
+		skus := append(n2AmericasSKUs(), catalogSKU("dup", "N2 Instance Core running in Americas", "CPU", "OnDemand", "h", 1, americas))
+		_, err := findFamilyRates(skus, "n2-standard-8", "us-central1", 1)
+		require.ErrorContains(t, err, "ambiguous catalog")
+	})
+	t.Run("usage type disagrees with description", func(t *testing.T) {
+		skus := n2AmericasSKUs()
+		skus[2].Category.UsageType = "Commit3Yr"
+		_, err := findFamilyRates(skus, "n2-standard-8", "us-central1", 1)
+		require.ErrorContains(t, err, "usage type")
+	})
+	t.Run("missing currency", func(t *testing.T) {
+		skus := n2AmericasSKUs()
+		skus[0].PricingInfo[0].PricingExpression.TieredRates[0].UnitPrice.CurrencyCode = ""
+		_, err := findFamilyRates(skus, "n2-standard-8", "us-central1", 1)
+		require.ErrorContains(t, err, "no currency")
+	})
+}
+
+func TestResourcesFromRecommendation_RequiresCountAndMemory(t *testing.T) {
+	_, err := resourcesFromRecommendation(newRec("n2-standard-8", 0, 32))
+	require.Error(t, err)
+	_, err = resourcesFromRecommendation(newRec("n2-standard-8", 8, 0))
+	require.Error(t, err)
+}
+
+// catalogServer serves nSKUs synthetic SKUs in pages of pageSize and records
+// the page tokens it was asked for.
+func catalogServer(t *testing.T, total, pageSize int, tokens *[]string) *httptest.Server {
+	t.Helper()
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		token := r.URL.Query().Get("pageToken")
+		*tokens = append(*tokens, token)
+		start := 0
+		if token != "" {
+			start, _ = strconv.Atoi(token)
+		}
+		end := min(start+pageSize, total)
+		body := `{"skus":[`
+		for i := start; i < end; i++ {
+			if i > start {
+				body += ","
+			}
+			body += fmt.Sprintf(`{"skuId":"sku-%d"}`, i)
+		}
+		body += `]`
+		if end < total {
+			body += fmt.Sprintf(`,"nextPageToken":"%d"`, end)
+		}
+		body += `}`
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(body))
+	}))
+}
+
+// The live Compute Engine catalog is 33,453 SKUs over 7 pages of 5,000; reading
+// only the first page left the commitment SKUs unseen.
+func TestRealBillingService_ListSKUsFollowsEveryPage(t *testing.T) {
+	var tokens []string
+	srv := catalogServer(t, 33453, 5000, &tokens)
+	defer srv.Close()
+
+	api, err := cloudbilling.NewService(context.Background(), option.WithEndpoint(srv.URL), option.WithoutAuthentication())
+	require.NoError(t, err)
+	svc := &realBillingService{ctx: context.Background(), service: api}
+
+	resp, err := svc.ListSKUs(computeServiceID)
+	require.NoError(t, err)
+	assert.Len(t, resp.Skus, 33453)
+	assert.Len(t, tokens, 7)
+}
+
+func TestRealBillingService_ListSKUsPageCap(t *testing.T) {
+	var tokens []string
+	srv := catalogServer(t, (maxSKUPages+1)*10, 10, &tokens)
+	defer srv.Close()
+
+	api, err := cloudbilling.NewService(context.Background(), option.WithEndpoint(srv.URL), option.WithoutAuthentication())
+	require.NoError(t, err)
+	svc := &realBillingService{ctx: context.Background(), service: api}
+
+	_, err = svc.ListSKUs(computeServiceID)
+	require.ErrorContains(t, err, "page cap")
+}
diff --git a/providers/gcp/services/computeengine/usage_type_test.go b/providers/gcp/services/computeengine/usage_type_test.go
deleted file mode 100644
index bd44ca90..00000000
--- a/providers/gcp/services/computeengine/usage_type_test.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package computeengine
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/api/cloudbilling/v1"
-)
-
-func usageTypeSKU(description, usageType string, nanos int32) *cloudbilling.Sku {
-	return &cloudbilling.Sku{
-		SkuId:          "sku-" + usageType,
-		Description:    description,
-		Category:       &cloudbilling.Category{UsageType: usageType},
-		ServiceRegions: []string{"us-central1"},
-		PricingInfo: []*cloudbilling.PricingInfo{{
-			PricingExpression: &cloudbilling.PricingExpression{
-				TieredRates: []*cloudbilling.TierRate{{
-					UnitPrice: &cloudbilling.Money{CurrencyCode: "USD", Nanos: int64(nanos)},
-				}},
-			},
-		}},
-	}
-}
-
-func TestExtractor_UsageTypeDecidesCommitmentSlot(t *testing.T) {
-	skus := []*cloudbilling.Sku{
-		usageTypeSKU("n1-standard-4 VM", "OnDemand", 50000000),
-		usageTypeSKU("n1-standard-4 VM Committed Use Discount", "Commit1Yr", 42000000),
-	}
-	onDemand, commitment, _, err := extractComputePricingFromSKUs(skus, "n1-standard-4", "us-central1")
-	require.NoError(t, err)
-	assert.InDelta(t, 0.05, onDemand, 1e-9)
-	assert.InDelta(t, 0.042, commitment, 1e-9)
-}
-
-func TestExtractor_UnknownUsageTypeIsAnError(t *testing.T) {
-	skus := []*cloudbilling.Sku{usageTypeSKU("n1-standard-4 VM", "Commit5Yr", 42000000)}
-	_, _, _, err := extractComputePricingFromSKUs(skus, "n1-standard-4", "us-central1")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "unrecognized usage type")
-}

From 2830cc5de405ba505ab05a0cd407dce97e703318 Mon Sep 17 00:00:00 2001
From: Cristian Magherusan-Stanciu <cristi.magherusan@gmail.com>
Date: Tue, 13 Oct 2026 20:55:25 +0200
Subject: [PATCH 2/5] refactor(gcp/computeengine): leave SKU paging to the
 shared helper

Paging is the shared helper's job (go#364 line of work); keep this change to
pricing.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../gcp/services/computeengine/client.go      | 20 +-----
 .../gcp/services/computeengine/pricing.go     |  6 --
 .../services/computeengine/pricing_test.go    | 64 -------------------
 3 files changed, 2 insertions(+), 88 deletions(-)

diff --git a/providers/gcp/services/computeengine/client.go b/providers/gcp/services/computeengine/client.go
index ab38e456..db2c72dc 100644
--- a/providers/gcp/services/computeengine/client.go
+++ b/providers/gcp/services/computeengine/client.go
@@ -341,27 +341,11 @@ func (r *realMachineTypesService) Close() error {
 
 // realBillingService wraps the real cloudbilling.APIService.
 type realBillingService struct {
-	ctx     context.Context
 	service *cloudbilling.APIService
 }
 
-// ListSKUs returns every SKU of the service. The catalog is paged (5000 SKUs per
-// page, 33k for Compute Engine), so all pages are followed.
 func (r *realBillingService) ListSKUs(serviceID string) (*cloudbilling.ListSkusResponse, error) {
-	all := &cloudbilling.ListSkusResponse{}
-	pages := 0
-	err := r.service.Services.Skus.List(serviceID).PageSize(skuPageSize).Pages(r.ctx, func(page *cloudbilling.ListSkusResponse) error {
-		pages++
-		if pages > maxSKUPages {
-			return fmt.Errorf("computeengine: billing SKU listing page cap (%d pages) reached", maxSKUPages)
-		}
-		all.Skus = append(all.Skus, page.Skus...)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return all, nil
+	return r.service.Services.Skus.List(serviceID).Do()
 }
 
 // realRecommenderIterator wraps the real recommender iterator.
@@ -1079,7 +1063,7 @@ func (c *Client) getOrCreateBillingService(ctx context.Context) (BillingService,
 		return nil, fmt.Errorf("failed to create billing service: %w", err)
 	}
 
-	return &realBillingService{ctx: ctx, service: service}, nil
+	return &realBillingService{service: service}, nil
 }
 
 // convertGCPRecommendation converts a GCP Recommender recommendation to common format.
diff --git a/providers/gcp/services/computeengine/pricing.go b/providers/gcp/services/computeengine/pricing.go
index a6cc14a4..c717c42e 100644
--- a/providers/gcp/services/computeengine/pricing.go
+++ b/providers/gcp/services/computeengine/pricing.go
@@ -16,12 +16,6 @@ const (
 	// computeServiceID is the Cloud Billing catalog service for Compute Engine.
 	computeServiceID = "services/6F81-5844-456A"
 
-	// skuPageSize is the largest page the catalog serves.
-	skuPageSize = 5000
-
-	// maxSKUPages caps catalog paging; Compute Engine is about 7 pages.
-	maxSKUPages = 50
-
 	hoursPerYear = 8760.0
 
 	usageUnitHour    = "h"
diff --git a/providers/gcp/services/computeengine/pricing_test.go b/providers/gcp/services/computeengine/pricing_test.go
index d2369799..2bd48989 100644
--- a/providers/gcp/services/computeengine/pricing_test.go
+++ b/providers/gcp/services/computeengine/pricing_test.go
@@ -2,16 +2,11 @@ package computeengine
 
 import (
 	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/api/cloudbilling/v1"
-	"google.golang.org/api/option"
 
 	"github.com/LeanerCloud/cloud-commitments-go/pkg/common"
 )
@@ -132,62 +127,3 @@ func TestResourcesFromRecommendation_RequiresCountAndMemory(t *testing.T) {
 	_, err = resourcesFromRecommendation(newRec("n2-standard-8", 8, 0))
 	require.Error(t, err)
 }
-
-// catalogServer serves nSKUs synthetic SKUs in pages of pageSize and records
-// the page tokens it was asked for.
-func catalogServer(t *testing.T, total, pageSize int, tokens *[]string) *httptest.Server {
-	t.Helper()
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		token := r.URL.Query().Get("pageToken")
-		*tokens = append(*tokens, token)
-		start := 0
-		if token != "" {
-			start, _ = strconv.Atoi(token)
-		}
-		end := min(start+pageSize, total)
-		body := `{"skus":[`
-		for i := start; i < end; i++ {
-			if i > start {
-				body += ","
-			}
-			body += fmt.Sprintf(`{"skuId":"sku-%d"}`, i)
-		}
-		body += `]`
-		if end < total {
-			body += fmt.Sprintf(`,"nextPageToken":"%d"`, end)
-		}
-		body += `}`
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(body))
-	}))
-}
-
-// The live Compute Engine catalog is 33,453 SKUs over 7 pages of 5,000; reading
-// only the first page left the commitment SKUs unseen.
-func TestRealBillingService_ListSKUsFollowsEveryPage(t *testing.T) {
-	var tokens []string
-	srv := catalogServer(t, 33453, 5000, &tokens)
-	defer srv.Close()
-
-	api, err := cloudbilling.NewService(context.Background(), option.WithEndpoint(srv.URL), option.WithoutAuthentication())
-	require.NoError(t, err)
-	svc := &realBillingService{ctx: context.Background(), service: api}
-
-	resp, err := svc.ListSKUs(computeServiceID)
-	require.NoError(t, err)
-	assert.Len(t, resp.Skus, 33453)
-	assert.Len(t, tokens, 7)
-}
-
-func TestRealBillingService_ListSKUsPageCap(t *testing.T) {
-	var tokens []string
-	srv := catalogServer(t, (maxSKUPages+1)*10, 10, &tokens)
-	defer srv.Close()
-
-	api, err := cloudbilling.NewService(context.Background(), option.WithEndpoint(srv.URL), option.WithoutAuthentication())
-	require.NoError(t, err)
-	svc := &realBillingService{ctx: context.Background(), service: api}
-
-	_, err = svc.ListSKUs(computeServiceID)
-	require.ErrorContains(t, err, "page cap")
-}

From 0fcebc21dfc6da510dab3c0eefff3df6289a0890 Mon Sep 17 00:00:00 2001
From: Cristian Magherusan-Stanciu <cristi.magherusan@gmail.com>
Date: Tue, 13 Oct 2026 20:57:14 +0200
Subject: [PATCH 3/5] fix(gcp/computeengine): report monthly CUD cost as
 recurring, not upfront

CommitmentCost is the upfront payment and is 0 for a monthly commitment;
the committed price goes to RecurringMonthlyCost. The platform adds upfront
plus monthly x term, so the term total in CommitmentCost was counted twice.
BreakEvenMonths is dropped: with no upfront payment there is none.

Closes #383
Refs platform#683

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../gcp/services/computeengine/client.go      | 44 +++++--------------
 .../gcp/services/computeengine/client_test.go | 10 +++--
 2 files changed, 19 insertions(+), 35 deletions(-)

diff --git a/providers/gcp/services/computeengine/client.go b/providers/gcp/services/computeengine/client.go
index db2c72dc..cb18257c 100644
--- a/providers/gcp/services/computeengine/client.go
+++ b/providers/gcp/services/computeengine/client.go
@@ -1067,8 +1067,8 @@ func (c *Client) getOrCreateBillingService(ctx context.Context) (BillingService,
 }
 
 // convertGCPRecommendation converts a GCP Recommender recommendation to common format.
-// It also calls getComputePricing to fill CommitmentCost/OnDemandCost/SavingsPercentage/
-// BreakEvenMonths so the scorer can filter and rank GCP recommendations correctly
+// It also calls getComputePricing to fill RecurringMonthlyCost/OnDemandCost/SavingsPercentage
+// so the scorer can filter and rank GCP recommendations correctly
 // (issue #1022 C2). Pricing failures are logged but do not discard the recommendation:
 // EstimatedSavings from the Recommender payload is the authoritative savings signal.
 // Returns nil when the params.Term is unrecognized so the caller skips an
@@ -1118,28 +1118,17 @@ func (c *Client) convertGCPRecommendation(ctx context.Context, gcpRec *recommend
 
 	c.enrichRecWithPricing(ctx, rec)
 
-	// GCP Compute CUDs are monthly-payment commitments (PaymentOption is forced
-	// to "monthly" above), so the per-month charge is CommitmentCost /
-	// termMonths. enrichRecWithPricing performs the single billing lookup and
-	// populates CommitmentCost; reuse it here rather than issuing a second call.
-	// When the billing lookup failed CommitmentCost stays 0 and we leave
-	// RecurringMonthlyCost nil (unknown) so the frontend renders "—" rather than
-	// an incorrect explicit "$0" (nil means unavailable, 0 means known-zero fee).
-	if rec.CommitmentCost > 0 {
-		termYears := termYearsFromTerm(rec.Term)
-		monthly := rec.CommitmentCost / float64(termYears*12)
-		rec.RecurringMonthlyCost = &monthly
-	}
-
 	return rec, nil
 }
 
-// enrichRecWithPricing fills CommitmentCost, OnDemandCost, SavingsPercentage,
-// and BreakEvenMonths on rec by querying the billing catalog. Extracted from
-// convertGCPRecommendation to keep that function's cyclomatic complexity under
-// the gocyclo gate. A missing or invalid pricing entry is logged but does not
-// discard the recommendation -- the Recommender-derived EstimatedSavings is
-// still the authoritative savings signal (issue #1022 C2).
+// enrichRecWithPricing fills OnDemandCost, SavingsPercentage and
+// RecurringMonthlyCost on rec from the billing catalog. The recommendation is a
+// monthly CUD with no upfront payment, so CommitmentCost (the upfront amount)
+// stays 0 and the committed price is the monthly recurring cost. OnDemandCost is
+// the on-demand price over the term. A missing or invalid pricing entry is logged
+// and leaves RecurringMonthlyCost nil (unknown, not zero) without discarding the
+// recommendation: the Recommender EstimatedSavings is still the authoritative
+// savings signal (issue #1022 C2).
 func (c *Client) enrichRecWithPricing(ctx context.Context, rec *common.Recommendation) {
 	if rec.ResourceType == "" {
 		return
@@ -1155,19 +1144,10 @@ func (c *Client) enrichRecWithPricing(ctx context.Context, rec *common.Recommend
 		log.Printf("computeengine: pricing unavailable for %s in %s (issue #1020): %v", rec.ResourceType, c.region, err)
 		return
 	}
-	rec.CommitmentCost = pricing.CommitmentPrice
+	monthly := pricing.CommitmentPrice / float64(termYears*12)
+	rec.RecurringMonthlyCost = &monthly
 	rec.OnDemandCost = pricing.OnDemandPrice
 	rec.SavingsPercentage = pricing.SavingsPercentage
-	// BreakEvenMonths: months of accrued savings required to cover the
-	// commitment cost (conservative: treats the whole period cost as sunk,
-	// which is accurate for all-upfront and overestimates for monthly CUDs).
-	// monthlySavings = monthly spend difference between on-demand and CUD.
-	if pricing.OnDemandPrice > 0 && pricing.SavingsPercentage > 0 {
-		monthlySavings := pricing.OnDemandPrice * pricing.SavingsPercentage / 100.0 / float64(termYears*12)
-		if monthlySavings > 0 {
-			rec.BreakEvenMonths = pricing.CommitmentPrice / monthlySavings
-		}
-	}
 }
 
 // machineTypePathSegment precedes the machine type in a GCP resource path, e.g.
diff --git a/providers/gcp/services/computeengine/client_test.go b/providers/gcp/services/computeengine/client_test.go
index e91ddc58..53d5b8ef 100644
--- a/providers/gcp/services/computeengine/client_test.go
+++ b/providers/gcp/services/computeengine/client_test.go
@@ -1179,8 +1179,8 @@ func TestComputeEngineClient_ConvertGCPRecommendation(t *testing.T) {
 	assert.Equal(t, 50.5, rec.EstimatedSavings)
 	assert.Equal(t, "monthly", rec.PaymentOption,
 		`GCP CUDs are billed monthly; PaymentOption must match ValidPaymentOptionsByProvider["gcp"]`)
-	// GCP Compute CUDs are monthly-billed and RecurringMonthlyCost is derived
-	// from CommitmentCost. No billing service is injected here, so the pricing
+	// GCP Compute CUDs are monthly-billed and RecurringMonthlyCost is priced from
+	// the billing catalog. No billing service is injected here, so the pricing
 	// lookup fails and the field stays nil (unknown) rather than an incorrect
 	// explicit 0 (nil means unavailable, 0 means a known-zero recurring fee).
 	assert.Nil(t, rec.RecurringMonthlyCost)
@@ -1348,7 +1348,11 @@ func TestConverterFillsPricingForScorer(t *testing.T) {
 	// C2: SavingsPercentage must be > 0 so a MinSavingsPct filter doesn't silently drop the rec.
 	require.Greater(t, rec.SavingsPercentage, float64(0),
 		"convertGCPRecommendation must set SavingsPercentage > 0 from billing pricing (issue #1022 C2)")
-	assert.Greater(t, rec.CommitmentCost, float64(0), "CommitmentCost must be > 0")
+	assert.Zero(t, rec.CommitmentCost, "a monthly CUD has no upfront payment, so CommitmentCost is 0 (platform computes upfront + monthly x term)")
+	require.NotNil(t, rec.RecurringMonthlyCost)
+	// 4 vCPU and 6 GiB at the 1-year N1 commitment rates, per month.
+	assert.InDelta(t, (4*0.019915+6*0.002669)*8760/12, *rec.RecurringMonthlyCost, 1e-6)
+	assert.Zero(t, rec.BreakEvenMonths, "no upfront payment, so there is nothing to break even on")
 	assert.Greater(t, rec.OnDemandCost, float64(0), "OnDemandCost must be > 0")
 
 	// Apply a non-trivial MinSavingsPct filter and confirm the rec passes.

From 1a255193315c795b3a3b037c17285ffb9af7ddab Mon Sep 17 00:00:00 2001
From: Cristian Magherusan-Stanciu <cristi.magherusan@gmail.com>
Date: Tue, 13 Oct 2026 21:09:45 +0200
Subject: [PATCH 4/5] fix(gcp/computeengine): satisfy gocritic weakCond and
 misspell lint

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 providers/gcp/services/computeengine/pricing.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/providers/gcp/services/computeengine/pricing.go b/providers/gcp/services/computeengine/pricing.go
index c717c42e..1c7fe255 100644
--- a/providers/gcp/services/computeengine/pricing.go
+++ b/providers/gcp/services/computeengine/pricing.go
@@ -116,7 +116,7 @@ func commitmentDescription(label string) *regexp.Regexp {
 	return regexp.MustCompile(`^Commitment v1: ` + family + `(Cpu|Ram) in .* for (1|3) Years?$`)
 }
 
-// rateMatcher recognises the catalog SKUs of one family, region and term.
+// rateMatcher recognizes the catalog SKUs of one family, region and term.
 type rateMatcher struct {
 	region      string
 	onDemand    *regexp.Regexp
@@ -151,7 +151,7 @@ func (m rateMatcher) classify(sku *cloudbilling.Sku) (isCommit, isRAM, matched b
 	}
 	for _, re := range m.commitments {
 		sub := re.FindStringSubmatch(sku.Description)
-		if sub == nil || sub[2] != m.wantTerm {
+		if len(sub) == 0 || sub[2] != m.wantTerm {
 			continue
 		}
 		if sku.Category.UsageType != m.wantUsage {

From 61020045d1b650a64c2f9d999873c81430225acf Mon Sep 17 00:00:00 2001
From: Cristian Magherusan-Stanciu <cristi.magherusan@gmail.com>
Date: Tue, 13 Oct 2026 21:56:34 +0200
Subject: [PATCH 5/5] fix(gcp/computeengine): report OnDemandCost monthly and
 cover the 3-year term

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../gcp/services/computeengine/client.go      |  8 ++++--
 .../services/computeengine/pricing_test.go    | 28 +++++++++++++++++++
 2 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/providers/gcp/services/computeengine/client.go b/providers/gcp/services/computeengine/client.go
index cb18257c..b4a8e5fb 100644
--- a/providers/gcp/services/computeengine/client.go
+++ b/providers/gcp/services/computeengine/client.go
@@ -1125,7 +1125,8 @@ func (c *Client) convertGCPRecommendation(ctx context.Context, gcpRec *recommend
 // RecurringMonthlyCost on rec from the billing catalog. The recommendation is a
 // monthly CUD with no upfront payment, so CommitmentCost (the upfront amount)
 // stays 0 and the committed price is the monthly recurring cost. OnDemandCost is
-// the on-demand price over the term. A missing or invalid pricing entry is logged
+// the monthly on-demand price of the same resources, like the AWS and Azure
+// providers and the platform baseline. A missing or invalid pricing entry is logged
 // and leaves RecurringMonthlyCost nil (unknown, not zero) without discarding the
 // recommendation: the Recommender EstimatedSavings is still the authoritative
 // savings signal (issue #1022 C2).
@@ -1144,9 +1145,10 @@ func (c *Client) enrichRecWithPricing(ctx context.Context, rec *common.Recommend
 		log.Printf("computeengine: pricing unavailable for %s in %s (issue #1020): %v", rec.ResourceType, c.region, err)
 		return
 	}
-	monthly := pricing.CommitmentPrice / float64(termYears*12)
+	termMonths := float64(termYears * 12)
+	monthly := pricing.CommitmentPrice / termMonths
 	rec.RecurringMonthlyCost = &monthly
-	rec.OnDemandCost = pricing.OnDemandPrice
+	rec.OnDemandCost = pricing.OnDemandPrice / termMonths
 	rec.SavingsPercentage = pricing.SavingsPercentage
 }
 
diff --git a/providers/gcp/services/computeengine/pricing_test.go b/providers/gcp/services/computeengine/pricing_test.go
index 2bd48989..33b32c0f 100644
--- a/providers/gcp/services/computeengine/pricing_test.go
+++ b/providers/gcp/services/computeengine/pricing_test.go
@@ -127,3 +127,31 @@ func TestResourcesFromRecommendation_RequiresCountAndMemory(t *testing.T) {
 	_, err = resourcesFromRecommendation(newRec("n2-standard-8", 8, 0))
 	require.Error(t, err)
 }
+
+// Monthly figures for n2-standard-8 (8 vCPU, 32 GiB), live-shaped rates, per term.
+// A division by 12 instead of termYears*12 would triple the 3-year amounts.
+func TestEnrichRecWithPricing_MonthlyFiguresPerTerm(t *testing.T) {
+	cases := map[string]struct {
+		term                   string
+		commitHourly, odHourly float64
+	}{
+		"1yr": {"1yr", 8*0.019915 + 32*0.002669, 8*0.031611 + 32*0.004237},
+		"3yr": {"3yr", 8*0.014225 + 32*0.001907, 8*0.031611 + 32*0.004237},
+	}
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			ctx := context.Background()
+			client, _ := NewClient(ctx, "p", "us-central1")
+			client.SetBillingService(&MockBillingService{skus: &cloudbilling.ListSkusResponse{Skus: n2AmericasSKUs()}})
+			rec := newRec("n2-standard-8", 8, 32)
+			rec.Term = tc.term
+
+			client.enrichRecWithPricing(ctx, &rec)
+
+			assert.Zero(t, rec.CommitmentCost)
+			require.NotNil(t, rec.RecurringMonthlyCost)
+			assert.InDelta(t, tc.commitHourly*730, *rec.RecurringMonthlyCost, 1e-6)
+			assert.InDelta(t, tc.odHourly*730, rec.OnDemandCost, 1e-6, "OnDemandCost is the monthly on-demand price")
+		})
+	}
+}