mirror of
https://github.com/kubernetes/kubernetes.git
synced 2026-03-21 18:11:55 -04:00
965 lines
31 KiB
Go
965 lines
31 KiB
Go
/*
|
|
Copyright The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package resourcepoolstatusrequest
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
resourcev1 "k8s.io/api/resource/v1"
|
|
resourcev1alpha3 "k8s.io/api/resource/v1alpha3"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/client-go/informers"
|
|
"k8s.io/client-go/kubernetes/fake"
|
|
"k8s.io/klog/v2/ktesting"
|
|
)
|
|
|
|
func TestCalculatePoolStatus(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
request *resourcev1alpha3.ResourcePoolStatusRequest
|
|
slices []*resourcev1.ResourceSlice
|
|
claims []*resourcev1.ResourceClaim
|
|
expectedPools int
|
|
expectedTotal int32
|
|
expectedAlloc int32
|
|
expectedPoolCount int32 // expected PoolCount value (total matching pools before limit)
|
|
expectedTruncated bool // true when len(Pools) < PoolCount
|
|
checkNodeName bool // when true, verify first pool's NodeName matches expectedNodeName
|
|
expectedNodeName *string // expected NodeName for the first pool (nil means no NodeName)
|
|
checkIncomplete bool // when true, verify incomplete pool behavior
|
|
expectedIncomplete int // number of pools expected to have ValidationError set
|
|
}{
|
|
{
|
|
name: "single-pool-no-allocations",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 4,
|
|
expectedAlloc: 0,
|
|
},
|
|
{
|
|
name: "single-pool-with-allocations",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{
|
|
makeAllocatedClaim("claim-1", "default", "test.example.com", "pool-1", "device-0"),
|
|
makeAllocatedClaim("claim-2", "default", "test.example.com", "pool-1", "device-1"),
|
|
},
|
|
expectedPools: 1,
|
|
expectedTotal: 4,
|
|
expectedAlloc: 2,
|
|
},
|
|
{
|
|
name: "multiple-pools",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
makeSlice("slice-2", "test.example.com", "pool-2", "node-2", 8),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 2,
|
|
expectedTotal: 12,
|
|
expectedAlloc: 0,
|
|
},
|
|
{
|
|
name: "filter-by-driver",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
makeSlice("slice-2", "other.example.com", "pool-2", "node-2", 8),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 4,
|
|
expectedAlloc: 0,
|
|
},
|
|
{
|
|
name: "filter-by-pool-name",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
PoolName: new("pool-1"),
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
makeSlice("slice-2", "test.example.com", "pool-2", "node-2", 8),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 4,
|
|
expectedAlloc: 0,
|
|
},
|
|
{
|
|
name: "multiple-slices-same-pool",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
makeSlice("slice-2", "test.example.com", "pool-1", "node-1", 4),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 8,
|
|
expectedAlloc: 0,
|
|
},
|
|
{
|
|
name: "limit-pools",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
Limit: new(int32(1)),
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
makeSlice("slice-2", "test.example.com", "pool-2", "node-2", 8),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedPoolCount: 2,
|
|
expectedTruncated: true,
|
|
},
|
|
{
|
|
name: "no-matching-pools",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "nonexistent.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 0,
|
|
expectedTotal: 0,
|
|
expectedAlloc: 0,
|
|
},
|
|
{
|
|
name: "older-generation-slices-ignored",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
// Old generation slice (should be ignored)
|
|
makeSliceWithGeneration("slice-old", "test.example.com", "pool-1", "node-1", 8, 1),
|
|
// New generation slices (should be counted)
|
|
makeSliceWithGeneration("slice-new-1", "test.example.com", "pool-1", "node-1", 4, 2),
|
|
makeSliceWithGeneration("slice-new-2", "test.example.com", "pool-1", "node-1", 4, 2),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 8, // 4+4 from gen 2 only, not 8 from gen 1
|
|
expectedAlloc: 0,
|
|
},
|
|
{
|
|
name: "incomplete-pool-has-validation-error",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
// Pool expects 5 slices but only 3 are published
|
|
makeSliceWithExpectedCount("slice-1", "test.example.com", "pool-1", "node-1", 4, 1, 5),
|
|
makeSliceWithExpectedCount("slice-2", "test.example.com", "pool-1", "node-1", 4, 1, 5),
|
|
makeSliceWithExpectedCount("slice-3", "test.example.com", "pool-1", "node-1", 4, 1, 5),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
checkIncomplete: true,
|
|
expectedIncomplete: 1,
|
|
},
|
|
{
|
|
name: "mix-of-complete-and-incomplete-pools",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
// pool-1: complete (1/1 slices)
|
|
makeSliceWithExpectedCount("slice-1", "test.example.com", "pool-1", "node-1", 4, 1, 1),
|
|
// pool-2: incomplete (2/3 slices)
|
|
makeSliceWithExpectedCount("slice-2a", "test.example.com", "pool-2", "node-2", 4, 1, 3),
|
|
makeSliceWithExpectedCount("slice-2b", "test.example.com", "pool-2", "node-2", 4, 1, 3),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 2,
|
|
expectedTotal: 4, // only pool-1 (complete) contributes to total
|
|
expectedAlloc: 0,
|
|
checkIncomplete: true,
|
|
expectedIncomplete: 1,
|
|
},
|
|
{
|
|
name: "same-node-pool-sets-nodename",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
makeSlice("slice-2", "test.example.com", "pool-1", "node-1", 4),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 8,
|
|
expectedAlloc: 0,
|
|
checkNodeName: true,
|
|
expectedNodeName: new("node-1"),
|
|
},
|
|
{
|
|
name: "mixed-node-pool-clears-nodename",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4),
|
|
makeSlice("slice-2", "test.example.com", "pool-1", "node-2", 4),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 8,
|
|
expectedAlloc: 0,
|
|
checkNodeName: true,
|
|
expectedNodeName: nil,
|
|
},
|
|
{
|
|
name: "nil-nodename-slices-no-nodename",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
makeSliceWithoutNode("slice-1", "test.example.com", "pool-1", 4),
|
|
makeSliceWithoutNode("slice-2", "test.example.com", "pool-1", 4),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 8,
|
|
expectedAlloc: 0,
|
|
checkNodeName: true,
|
|
expectedNodeName: nil,
|
|
},
|
|
{
|
|
name: "all-pools-complete-no-validation-errors",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
},
|
|
slices: []*resourcev1.ResourceSlice{
|
|
// pool-1: complete (2/2 slices)
|
|
makeSliceWithExpectedCount("slice-1a", "test.example.com", "pool-1", "node-1", 4, 1, 2),
|
|
makeSliceWithExpectedCount("slice-1b", "test.example.com", "pool-1", "node-1", 4, 1, 2),
|
|
},
|
|
claims: []*resourcev1.ResourceClaim{},
|
|
expectedPools: 1,
|
|
expectedTotal: 8,
|
|
expectedAlloc: 0,
|
|
checkIncomplete: true,
|
|
expectedIncomplete: 0,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
// Create fake client and informers
|
|
fakeClient := fake.NewClientset()
|
|
informerFactory := informers.NewSharedInformerFactory(fakeClient, 0)
|
|
|
|
// Create controller
|
|
controller, err := NewController(ctx, fakeClient,
|
|
informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests(),
|
|
informerFactory.Resource().V1().ResourceSlices(),
|
|
informerFactory.Resource().V1().ResourceClaims(),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create controller: %v", err)
|
|
}
|
|
|
|
// Add slices to the informer store
|
|
for _, slice := range tc.slices {
|
|
err := informerFactory.Resource().V1().ResourceSlices().Informer().GetStore().Add(slice)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add slice to informer: %v", err)
|
|
}
|
|
}
|
|
|
|
// Add claims to the informer store
|
|
for _, claim := range tc.claims {
|
|
err := informerFactory.Resource().V1().ResourceClaims().Informer().GetStore().Add(claim)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add claim to informer: %v", err)
|
|
}
|
|
}
|
|
|
|
// Calculate pool status (reads directly from listers)
|
|
status := controller.calculatePoolStatus(ctx, tc.request)
|
|
|
|
// Verify pool count
|
|
if len(status.Pools) != tc.expectedPools {
|
|
t.Errorf("Expected %d pools, got %d", tc.expectedPools, len(status.Pools))
|
|
}
|
|
|
|
// Verify PoolCount field
|
|
if tc.expectedPoolCount > 0 {
|
|
if status.PoolCount == nil {
|
|
t.Errorf("Expected PoolCount to be %d, got nil", tc.expectedPoolCount)
|
|
} else if *status.PoolCount != tc.expectedPoolCount {
|
|
t.Errorf("Expected PoolCount %d, got %d", tc.expectedPoolCount, *status.PoolCount)
|
|
}
|
|
}
|
|
|
|
// Verify truncation: len(Pools) < PoolCount means truncated
|
|
if tc.expectedTruncated {
|
|
if status.PoolCount == nil || int32(len(status.Pools)) >= *status.PoolCount {
|
|
t.Errorf("Expected truncation (len(Pools)=%d < PoolCount), but PoolCount=%v", len(status.Pools), status.PoolCount)
|
|
}
|
|
}
|
|
|
|
// Count device totals from complete pools only (those without ValidationError)
|
|
if tc.expectedPools > 0 && !tc.expectedTruncated {
|
|
var totalDevices, allocatedDevices int32
|
|
for _, pool := range status.Pools {
|
|
if pool.TotalDevices != nil {
|
|
totalDevices += *pool.TotalDevices
|
|
}
|
|
if pool.AllocatedDevices != nil {
|
|
allocatedDevices += *pool.AllocatedDevices
|
|
}
|
|
}
|
|
if totalDevices != tc.expectedTotal {
|
|
t.Errorf("Expected total devices %d, got %d", tc.expectedTotal, totalDevices)
|
|
}
|
|
if allocatedDevices != tc.expectedAlloc {
|
|
t.Errorf("Expected allocated devices %d, got %d", tc.expectedAlloc, allocatedDevices)
|
|
}
|
|
}
|
|
|
|
// Verify NodeName when test specifies expected value
|
|
if tc.checkNodeName && len(status.Pools) == 1 {
|
|
pool := status.Pools[0]
|
|
if tc.expectedNodeName != nil {
|
|
if pool.NodeName == nil {
|
|
t.Errorf("Expected NodeName %q, got nil", *tc.expectedNodeName)
|
|
} else if *pool.NodeName != *tc.expectedNodeName {
|
|
t.Errorf("Expected NodeName %q, got %q", *tc.expectedNodeName, *pool.NodeName)
|
|
}
|
|
} else if pool.NodeName != nil {
|
|
t.Errorf("Expected NodeName to be nil, got %q", *pool.NodeName)
|
|
}
|
|
}
|
|
|
|
// Verify incomplete pool counts (pools with ValidationError set)
|
|
if tc.checkIncomplete {
|
|
incompleteCount := 0
|
|
for _, pool := range status.Pools {
|
|
if pool.ValidationError != nil {
|
|
incompleteCount++
|
|
// Incomplete pools should have nil device counts and nil ResourceSliceCount
|
|
if pool.TotalDevices != nil {
|
|
t.Errorf("Incomplete pool %s/%s should have nil TotalDevices, got %d", pool.Driver, pool.PoolName, *pool.TotalDevices)
|
|
}
|
|
if pool.AllocatedDevices != nil {
|
|
t.Errorf("Incomplete pool %s/%s should have nil AllocatedDevices, got %d", pool.Driver, pool.PoolName, *pool.AllocatedDevices)
|
|
}
|
|
if pool.ResourceSliceCount != nil {
|
|
t.Errorf("Incomplete pool %s/%s should have nil ResourceSliceCount, got %d", pool.Driver, pool.PoolName, *pool.ResourceSliceCount)
|
|
}
|
|
}
|
|
}
|
|
if incompleteCount != tc.expectedIncomplete {
|
|
t.Errorf("Expected %d incomplete pools (with ValidationError), got %d", tc.expectedIncomplete, incompleteCount)
|
|
}
|
|
}
|
|
|
|
// Verify conditions are set
|
|
if len(status.Conditions) == 0 {
|
|
t.Error("Expected Conditions to be set")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSyncRequest(t *testing.T) {
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
// Create fake client and informers
|
|
request := &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
}
|
|
|
|
fakeClient := fake.NewClientset(request)
|
|
informerFactory := informers.NewSharedInformerFactory(fakeClient, 0)
|
|
|
|
// Create controller
|
|
controller, err := NewController(ctx, fakeClient,
|
|
informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests(),
|
|
informerFactory.Resource().V1().ResourceSlices(),
|
|
informerFactory.Resource().V1().ResourceClaims(),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create controller: %v", err)
|
|
}
|
|
|
|
// Add request to informer
|
|
err = informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests().Informer().GetStore().Add(request)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add request to informer: %v", err)
|
|
}
|
|
|
|
// Add a slice
|
|
slice := makeSlice("slice-1", "test.example.com", "pool-1", "node-1", 4)
|
|
err = informerFactory.Resource().V1().ResourceSlices().Informer().GetStore().Add(slice)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add slice to informer: %v", err)
|
|
}
|
|
|
|
// Sync the request
|
|
err = controller.syncRequest(ctx, "test-request")
|
|
if err != nil {
|
|
t.Fatalf("syncRequest failed: %v", err)
|
|
}
|
|
|
|
// Verify the status was updated (fake client should have received UpdateStatus call)
|
|
actions := fakeClient.Actions()
|
|
var foundUpdate bool
|
|
for _, action := range actions {
|
|
if action.GetVerb() == "update" && action.GetSubresource() == "status" {
|
|
foundUpdate = true
|
|
break
|
|
}
|
|
}
|
|
if !foundUpdate {
|
|
t.Error("Expected status update action, but none found")
|
|
}
|
|
}
|
|
|
|
func TestSyncRequestRequeuesIncompletePool(t *testing.T) {
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
request := &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
}
|
|
|
|
fakeClient := fake.NewClientset(request)
|
|
informerFactory := informers.NewSharedInformerFactory(fakeClient, 0)
|
|
|
|
controller, err := NewController(ctx, fakeClient,
|
|
informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests(),
|
|
informerFactory.Resource().V1().ResourceSlices(),
|
|
informerFactory.Resource().V1().ResourceClaims(),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create controller: %v", err)
|
|
}
|
|
|
|
// Add request to informer
|
|
err = informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests().Informer().GetStore().Add(request)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add request to informer: %v", err)
|
|
}
|
|
|
|
// Add an incomplete pool (expects 3 slices, only 1 published)
|
|
slice := makeSliceWithExpectedCount("slice-1", "test.example.com", "pool-1", "node-1", 4, 1, 3)
|
|
err = informerFactory.Resource().V1().ResourceSlices().Informer().GetStore().Add(slice)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add slice to informer: %v", err)
|
|
}
|
|
|
|
// syncRequest should always return an error for incomplete pools,
|
|
// letting processNextWorkItem handle retry counting and drop logic.
|
|
err = controller.syncRequest(ctx, "test-request")
|
|
if err == nil {
|
|
t.Fatal("Expected syncRequest to return error for incomplete pool requeue, got nil")
|
|
}
|
|
|
|
// Verify no status update was made
|
|
for _, action := range fakeClient.Actions() {
|
|
if action.GetVerb() == "update" && action.GetSubresource() == "status" {
|
|
t.Error("Should not update status when requeueing for incomplete pools")
|
|
}
|
|
}
|
|
|
|
// Even after retries are exhausted, syncRequest still returns an error;
|
|
// it is processNextWorkItem that decides to drop the key.
|
|
for range maxRetries {
|
|
controller.workqueue.AddRateLimited("test-request")
|
|
key, _ := controller.workqueue.Get()
|
|
controller.workqueue.Done(key)
|
|
}
|
|
|
|
fakeClient.ClearActions()
|
|
err = controller.syncRequest(ctx, "test-request")
|
|
if err == nil {
|
|
t.Fatal("Expected syncRequest to still return error for incomplete pools after retries exhausted")
|
|
}
|
|
}
|
|
|
|
func TestSkipProcessedRequest(t *testing.T) {
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
now := metav1.Now()
|
|
// Create a request that's already been processed (Status is non-nil with conditions)
|
|
request := &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test-request"},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
Status: &resourcev1alpha3.ResourcePoolStatusRequestStatus{
|
|
PoolCount: new(int32(0)),
|
|
Conditions: []metav1.Condition{
|
|
{
|
|
Type: resourcev1alpha3.ResourcePoolStatusRequestConditionComplete,
|
|
Status: metav1.ConditionTrue,
|
|
LastTransitionTime: now,
|
|
Reason: "CalculationComplete",
|
|
Message: "Calculated status for 0 pools",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
fakeClient := fake.NewClientset(request)
|
|
informerFactory := informers.NewSharedInformerFactory(fakeClient, 0)
|
|
|
|
controller, err := NewController(ctx, fakeClient,
|
|
informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests(),
|
|
informerFactory.Resource().V1().ResourceSlices(),
|
|
informerFactory.Resource().V1().ResourceClaims(),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create controller: %v", err)
|
|
}
|
|
|
|
err = informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests().Informer().GetStore().Add(request)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add request to informer: %v", err)
|
|
}
|
|
|
|
// Sync should skip the already-processed request
|
|
err = controller.syncRequest(ctx, "test-request")
|
|
if err != nil {
|
|
t.Fatalf("syncRequest failed: %v", err)
|
|
}
|
|
|
|
// Verify no update was made
|
|
actions := fakeClient.Actions()
|
|
for _, action := range actions {
|
|
if action.GetVerb() == "update" && action.GetSubresource() == "status" {
|
|
t.Error("Should not update status for already-processed request")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Helper functions
|
|
|
|
func makeSlice(name, driver, pool, node string, deviceCount int) *resourcev1.ResourceSlice {
|
|
return makeSliceWithGenerationAndCount(name, driver, pool, node, deviceCount, 1, 1)
|
|
}
|
|
|
|
func makeSliceWithExpectedCount(name, driver, pool, node string, deviceCount int, generation int64, resourceSliceCount int64) *resourcev1.ResourceSlice {
|
|
return makeSliceWithGenerationAndCount(name, driver, pool, node, deviceCount, generation, resourceSliceCount)
|
|
}
|
|
|
|
func makeSliceWithGeneration(name, driver, pool, node string, deviceCount int, generation int64) *resourcev1.ResourceSlice {
|
|
return makeSliceWithGenerationAndCount(name, driver, pool, node, deviceCount, generation, 1)
|
|
}
|
|
|
|
func makeSliceWithGenerationAndCount(name, driver, pool, node string, deviceCount int, generation int64, resourceSliceCount int64) *resourcev1.ResourceSlice {
|
|
devices := make([]resourcev1.Device, deviceCount)
|
|
for i := range deviceCount {
|
|
devices[i] = resourcev1.Device{
|
|
Name: fmt.Sprintf("device-%d", i),
|
|
}
|
|
}
|
|
|
|
return &resourcev1.ResourceSlice{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: name,
|
|
},
|
|
Spec: resourcev1.ResourceSliceSpec{
|
|
Driver: driver,
|
|
NodeName: &node,
|
|
Pool: resourcev1.ResourcePool{
|
|
Name: pool,
|
|
Generation: generation,
|
|
ResourceSliceCount: resourceSliceCount,
|
|
},
|
|
Devices: devices,
|
|
},
|
|
}
|
|
}
|
|
|
|
func makeAllocatedClaim(name, namespace, driver, pool, device string) *resourcev1.ResourceClaim {
|
|
return &resourcev1.ResourceClaim{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: name,
|
|
Namespace: namespace,
|
|
},
|
|
Spec: resourcev1.ResourceClaimSpec{},
|
|
Status: resourcev1.ResourceClaimStatus{
|
|
Allocation: &resourcev1.AllocationResult{
|
|
Devices: resourcev1.DeviceAllocationResult{
|
|
Results: []resourcev1.DeviceRequestAllocationResult{
|
|
{
|
|
Driver: driver,
|
|
Pool: pool,
|
|
Device: device,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func TestIsOlderThan(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
time time.Time
|
|
duration time.Duration
|
|
expected bool
|
|
}{
|
|
{
|
|
name: "zero-time-is-not-older",
|
|
time: time.Time{},
|
|
duration: time.Hour,
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "recent-time-is-not-older",
|
|
time: time.Now().Add(-30 * time.Minute),
|
|
duration: time.Hour,
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "old-time-is-older",
|
|
time: time.Now().Add(-2 * time.Hour),
|
|
duration: time.Hour,
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "just-under-boundary-is-not-older",
|
|
time: time.Now().Add(-time.Hour + time.Minute),
|
|
duration: time.Hour,
|
|
expected: false,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
result := isOlderThan(tc.time, tc.duration)
|
|
if result != tc.expected {
|
|
t.Errorf("isOlderThan(%v, %v) = %v, expected %v", tc.time, tc.duration, result, tc.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestShouldDeleteRequest(t *testing.T) {
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
fakeClient := fake.NewClientset()
|
|
informerFactory := informers.NewSharedInformerFactory(fakeClient, 0)
|
|
|
|
controller, err := NewController(ctx, fakeClient,
|
|
informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests(),
|
|
informerFactory.Resource().V1().ResourceSlices(),
|
|
informerFactory.Resource().V1().ResourceClaims(),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create controller: %v", err)
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
request *resourcev1alpha3.ResourcePoolStatusRequest
|
|
expectedDelete bool
|
|
}{
|
|
{
|
|
name: "completed-request-not-expired",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "test-request",
|
|
CreationTimestamp: metav1.Now(),
|
|
},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
Status: &resourcev1alpha3.ResourcePoolStatusRequestStatus{
|
|
PoolCount: new(int32(0)),
|
|
Conditions: []metav1.Condition{
|
|
{
|
|
Type: resourcev1alpha3.ResourcePoolStatusRequestConditionComplete,
|
|
Status: metav1.ConditionTrue,
|
|
LastTransitionTime: metav1.Now(),
|
|
Reason: "CalculationComplete",
|
|
Message: "Calculated status for 0 pools",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedDelete: false,
|
|
},
|
|
{
|
|
name: "completed-request-expired",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "test-request",
|
|
CreationTimestamp: metav1.NewTime(time.Now().Add(-2 * time.Hour)),
|
|
},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
Status: &resourcev1alpha3.ResourcePoolStatusRequestStatus{
|
|
PoolCount: new(int32(0)),
|
|
Conditions: []metav1.Condition{
|
|
{
|
|
Type: resourcev1alpha3.ResourcePoolStatusRequestConditionComplete,
|
|
Status: metav1.ConditionTrue,
|
|
LastTransitionTime: metav1.NewTime(time.Now().Add(-2 * time.Hour)),
|
|
Reason: "CalculationComplete",
|
|
Message: "Calculated status for 0 pools",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedDelete: true,
|
|
},
|
|
{
|
|
name: "pending-request-not-expired",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "test-request",
|
|
CreationTimestamp: metav1.Now(),
|
|
},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
// No status - request is pending
|
|
},
|
|
expectedDelete: false,
|
|
},
|
|
{
|
|
name: "pending-request-expired",
|
|
request: &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "test-request",
|
|
CreationTimestamp: metav1.NewTime(time.Now().Add(-25 * time.Hour)),
|
|
},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
// No status - pending request expired
|
|
},
|
|
expectedDelete: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
result := controller.shouldDeleteRequest(tc.request)
|
|
if result != tc.expectedDelete {
|
|
t.Errorf("shouldDeleteRequest() = %v, expected %v", result, tc.expectedDelete)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCleanupExpiredRequests(t *testing.T) {
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
// Create requests: one expired, one not expired
|
|
expiredRequest := &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "expired-request",
|
|
CreationTimestamp: metav1.NewTime(time.Now().Add(-2 * time.Hour)),
|
|
},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
Status: &resourcev1alpha3.ResourcePoolStatusRequestStatus{
|
|
PoolCount: new(int32(0)),
|
|
Conditions: []metav1.Condition{
|
|
{
|
|
Type: resourcev1alpha3.ResourcePoolStatusRequestConditionComplete,
|
|
Status: metav1.ConditionTrue,
|
|
LastTransitionTime: metav1.NewTime(time.Now().Add(-2 * time.Hour)),
|
|
Reason: "CalculationComplete",
|
|
Message: "Calculated status for 0 pools",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
activeRequest := &resourcev1alpha3.ResourcePoolStatusRequest{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "active-request",
|
|
CreationTimestamp: metav1.Now(),
|
|
},
|
|
Spec: resourcev1alpha3.ResourcePoolStatusRequestSpec{
|
|
Driver: "test.example.com",
|
|
},
|
|
Status: &resourcev1alpha3.ResourcePoolStatusRequestStatus{
|
|
PoolCount: new(int32(0)),
|
|
Conditions: []metav1.Condition{
|
|
{
|
|
Type: resourcev1alpha3.ResourcePoolStatusRequestConditionComplete,
|
|
Status: metav1.ConditionTrue,
|
|
LastTransitionTime: metav1.Now(),
|
|
Reason: "CalculationComplete",
|
|
Message: "Calculated status for 0 pools",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
fakeClient := fake.NewClientset(expiredRequest, activeRequest)
|
|
informerFactory := informers.NewSharedInformerFactory(fakeClient, 0)
|
|
|
|
controller, err := NewController(ctx, fakeClient,
|
|
informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests(),
|
|
informerFactory.Resource().V1().ResourceSlices(),
|
|
informerFactory.Resource().V1().ResourceClaims(),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create controller: %v", err)
|
|
}
|
|
|
|
// Add requests to informer store
|
|
err = informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests().Informer().GetStore().Add(expiredRequest)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add expired request to informer: %v", err)
|
|
}
|
|
err = informerFactory.Resource().V1alpha3().ResourcePoolStatusRequests().Informer().GetStore().Add(activeRequest)
|
|
if err != nil {
|
|
t.Fatalf("Failed to add active request to informer: %v", err)
|
|
}
|
|
|
|
// Run cleanup
|
|
controller.cleanupExpiredRequests(ctx)
|
|
|
|
// Verify that delete was called for expired request
|
|
actions := fakeClient.Actions()
|
|
var deletedExpired, deletedActive bool
|
|
for _, action := range actions {
|
|
if action.GetVerb() == "delete" {
|
|
deleteAction, ok := action.(interface{ GetName() string })
|
|
if ok {
|
|
if deleteAction.GetName() == "expired-request" {
|
|
deletedExpired = true
|
|
}
|
|
if deleteAction.GetName() == "active-request" {
|
|
deletedActive = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if !deletedExpired {
|
|
t.Error("Expected expired-request to be deleted")
|
|
}
|
|
if deletedActive {
|
|
t.Error("Did not expect active-request to be deleted")
|
|
}
|
|
}
|
|
|
|
func makeSliceWithoutNode(name, driver, pool string, deviceCount int) *resourcev1.ResourceSlice {
|
|
devices := make([]resourcev1.Device, deviceCount)
|
|
for i := range deviceCount {
|
|
devices[i] = resourcev1.Device{
|
|
Name: fmt.Sprintf("device-%d", i),
|
|
}
|
|
}
|
|
|
|
return &resourcev1.ResourceSlice{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: name,
|
|
},
|
|
Spec: resourcev1.ResourceSliceSpec{
|
|
Driver: driver,
|
|
Pool: resourcev1.ResourcePool{
|
|
Name: pool,
|
|
Generation: 1,
|
|
ResourceSliceCount: 1,
|
|
},
|
|
Devices: devices,
|
|
},
|
|
}
|
|
}
|
|
|
|
// new is a generic helper to create a pointer to a value.
|
|
func new[T any](v T) *T {
|
|
return &v
|
|
}
|