测试指南

// pkg/scheduler/plugins/gang/gang_test.go
package gang

import (
    "testing"

    "volcano.sh/volcano/pkg/scheduler/api"
    "volcano.sh/volcano/pkg/scheduler/framework"
    "volcano.sh/volcano/pkg/scheduler/uthelper"
)

func TestGangScheduling(t *testing.T) {
    tests := []struct {
        name     string
        jobs     []*api.JobInfo
        nodes    []*api.NodeInfo
        queues   []*api.QueueInfo
        expected map[string]string  // task -> node
    }{
        {
            name: "gang all-or-nothing",
            // 构造测试场景
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // 执行测试
        })
    }
}

func TestJobController(t *testing.T) {
    // 使用 fake client
    kubeClient := fake.NewSimpleClientset()
    vcClient := vcfake.NewSimpleClientset()

    // 创建 Controller
    ctrl := &jobController{
        kubeClient: kubeClient,
        vcClient:   vcClient,
    }

    // 创建测试资源
    job := &vcbatch.Job{
        ObjectMeta: metav1.ObjectMeta{
            Name:      "test-job",
            Namespace: "default",
        },
        Spec: vcbatch.JobSpec{
            MinAvailable: 2,
        },
    }

    vcClient.BatchV1alpha1().Jobs("default").Create(
        context.TODO(), job, metav1.CreateOptions{})

    // 执行 Reconcile
    err := ctrl.reconcile("default/test-job")
    if err != nil {
        t.Errorf("reconcile failed: %v", err)
    }

    // 验证结果
}

func TestJobValidation(t *testing.T) {
    tests := []struct {
        name    string
        job     *vcbatch.Job
        allowed bool
    }{
        {
            name: "valid job",
            job: &vcbatch.Job{
                Spec: vcbatch.JobSpec{
                    MinAvailable: 2,
                    Tasks: []vcbatch.TaskSpec{
                        {Replicas: 2, Name: "worker"},
                    },
                },
            },
            allowed: true,
        },
        {
            name: "minAvailable exceeds replicas",
            job: &vcbatch.Job{
                Spec: vcbatch.JobSpec{
                    MinAvailable: 5,
                    Tasks: []vcbatch.TaskSpec{
                        {Replicas: 2, Name: "worker"},
                    },
                },
            },
            allowed: false,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            raw, _ := json.Marshal(tt.job)
            review := admissionv1.AdmissionReview{
                Request: &admissionv1.AdmissionRequest{
                    Object:    runtime.RawExtension{Raw: raw},
                    Operation: admissionv1.Create,
                },
            }

            resp := validateJob(review)
            if resp.Allowed != tt.allowed {
                t.Errorf("expected allowed=%v, got %v", tt.allowed, resp.Allowed)
            }
        })
    }
}

// test/e2e/jobp/main_test.go
package jobp

import (
    "os"
    "testing"

    "volcano.sh/volcano/test/e2e/util"
)

func TestMain(m *testing.M) {
    // 初始化客户端
    home := util.HomeDir()
    configPath := util.KubeconfigPath(home)
    config, _ := clientcmd.BuildConfigFromFlags(util.MasterURL(), configPath)
    util.VcClient = vcclient.NewForConfigOrDie(config)
    util.KubeClient = kubernetes.NewForConfigOrDie(config)

    os.Exit(m.Run())
}

func TestE2E(t *testing.T) {
    RegisterFailHandler(Fail)
    RunSpecs(t, "Volcano Job Test Suite")
}

// test/e2e/jobp/job_test.go
var _ = ginkgo.Describe("Job E2E Test", func() {

    ginkgo.It("should schedule job when resources are sufficient", func() {
        // 1. 初始化测试上下文
        ctx := e2eutil.InitTestContext(e2eutil.Options{
            NodesNumLimit: 3,
            NodesResourceLimit: corev1.ResourceList{
                corev1.ResourceCPU:    resource.MustParse("2000m"),
                corev1.ResourceMemory: resource.MustParse("2048Mi"),
            },
        })
        defer e2eutil.CleanupTestContext(ctx)

        // 2. 创建 Job
        job := &e2eutil.JobSpec{
            Name:      "test-job",
            Queue:     "default",
            Min:       2,
            Tasks: []e2eutil.TaskSpec{
                {
                    Name: "worker",
                    Img:  e2eutil.DefaultNginxImage,
                    Min:  2,
                    Rep:  2,
                    Req: corev1.ResourceList{
                        corev1.ResourceCPU: resource.MustParse("500m"),
                    },
                },
            },
        }
        createdJob := e2eutil.CreateJob(ctx, job)

        // 3. 等待并验证
        err := e2eutil.WaitJobReady(ctx, createdJob)
        gomega.Expect(err).NotTo(gomega.HaveOccurred())

        // 4. 验证 Pod 数量
        pods := e2eutil.GetJobPods(ctx, createdJob)
        gomega.Expect(len(pods)).To(gomega.Equal(2))
    })

    ginkgo.It("should handle gang scheduling timeout", func() {
        ctx := e2eutil.InitTestContext(e2eutil.Options{
            NodesNumLimit: 1,
            NodesResourceLimit: corev1.ResourceList{
                corev1.ResourceCPU: resource.MustParse("1000m"),
            },
        })
        defer e2eutil.CleanupTestContext(ctx)

        // 创建需要 4 CPU 但集群只有 1 CPU 的 Job
        job := &e2eutil.JobSpec{
            Name: "gang-timeout",
            Min:  2,
            Tasks: []e2eutil.TaskSpec{
                {
                    Name: "worker",
                    Img:  e2eutil.DefaultNginxImage,
                    Min:  2,
                    Rep:  2,
                    Req: corev1.ResourceList{
                        corev1.ResourceCPU: resource.MustParse("2000m"),
                    },
                },
            },
        }
        createdJob := e2eutil.CreateJob(ctx, job)

        // 验证 Job 保持 Pending
        err := e2eutil.WaitJobPending(ctx, createdJob)
        gomega.Expect(err).NotTo(gomega.HaveOccurred())
    })
})