@nexusgpu/repterm-plugin-kubectl 0.1.0

package/dist/plugin-kubectl/examples/tensor-fusion/04-release.js

@@ -0,0 +1,117 @@
+/**
+ * 测试场景 4: 资源释放验证
+ *
+ * 验证删除 TensorFusionWorkload 后：
+ * - GPU 资源正确释放
+ * - 可用资源恢复到初始值
+ * - 关联的 Worker Pod 被清理
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/04-release.ts
+ */
+import { test, describe, expect, step, tensorfusionworkload, workloadYaml, DEFAULT_TIMEOUT, getFirstGpuName, getGpuAvailable, parseTflops, } from './_config.js';
+const WORKLOAD_NAME = 'test-workload-release';
+describe('测试场景 4: 资源释放验证', { record: true }, () => {
+    let gpuName;
+    let initialTflops;
+    let allocatedTflops;
+    // ===== Step 1: 记录初始状态 =====
+    test('Step 1: 记录初始 GPU 资源状态', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        kubectl.get();
+        await step('获取测试 GPU', async () => {
+            gpuName = await getFirstGpuName(kubectl);
+        });
+        await step('记录初始可用资源', async () => {
+            const available = await getGpuAvailable(kubectl, gpuName);
+            initialTflops = available.tflops;
+        });
+    });
+    // ===== Step 2: 创建并等待 Workload 就绪 =====
+    test('Step 2: 创建 TensorFusionWorkload 并等待就绪', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('创建 Workload', async () => {
+            const yaml = workloadYaml(WORKLOAD_NAME, {
+                tflopsRequest: '1000m',
+                tflopsLimit: '2000m',
+                vramRequest: '1Gi',
+                vramLimit: '2Gi',
+            });
+            const result = await kubectl.apply(yaml);
+            await expect(result).toBeSuccessful();
+        });
+        await step('等待 Workload 就绪', async () => {
+            await kubectl.wait('tensorfusionworkload', WORKLOAD_NAME, 'Ready', { timeout: DEFAULT_TIMEOUT });
+        });
+        await step('记录分配后的资源', async () => {
+            const available = await getGpuAvailable(kubectl, gpuName);
+            allocatedTflops = available.tflops;
+            const initialNum = parseTflops(initialTflops);
+            const allocatedNum = parseTflops(allocatedTflops);
+            // 验证资源确实被分配了
+            expect(allocatedNum).toBeLessThan(initialNum);
+        });
+    });
+    // ===== Step 3: 确认 Worker Pod 存在 =====
+    test('Step 3: 确认 Worker Pod 存在', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('查找 Worker Pod', async () => {
+            const pods = await kubectl.get('pod', undefined, { selector: `tensor-fusion.ai/workload=${WORKLOAD_NAME}` });
+            expect(pods.items?.length).toBeGreaterThan(0);
+            expect(pods.items[0].status.phase).toBe('Running');
+        });
+    });
+    // ===== Step 4: 删除 Workload =====
+    test('Step 4: 删除 TensorFusionWorkload', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('删除 Workload', async () => {
+            const result = await kubectl.delete('tensorfusionworkload', WORKLOAD_NAME);
+            await expect(result).toBeSuccessful();
+        });
+        await step('等待 Workload 删除完成', async () => {
+            const startTime = Date.now();
+            const timeout = 30000;
+            while (Date.now() - startTime < timeout) {
+                const exists = await kubectl.exists('tensorfusionworkload', WORKLOAD_NAME);
+                if (!exists) {
+                    return;
+                }
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+            // 超时后断言 workload 不存在
+            const exists = await kubectl.exists('tensorfusionworkload', WORKLOAD_NAME);
+            expect(exists).toBe(false);
+        });
+    });
+    // ===== Step 5: 验证资源释放 =====
+    test('Step 5: 验证 GPU 资源已释放', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('等待资源释放', async () => {
+            await new Promise(resolve => setTimeout(resolve, 5000));
+        });
+        await step('检查 GPU 可用资源', async () => {
+            const releasedAvailable = await getGpuAvailable(kubectl, gpuName);
+            const initialNum = parseTflops(initialTflops);
+            const releasedNum = parseTflops(releasedAvailable.tflops);
+            // 验证资源已恢复（允许小误差）
+            expect(Math.abs(releasedNum - initialNum)).toBeLessThan(100);
+        });
+    });
+    // ===== Step 6: 验证 Worker Pod 已清理 =====
+    test('Step 6: 验证 Worker Pod 已清理', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('检查 Worker Pod', async () => {
+            const pods = await kubectl.get('pod', undefined, { selector: `tensor-fusion.ai/workload=${WORKLOAD_NAME}` });
+            // Worker Pod 应该已被删除
+            expect(pods.items?.length ?? 0).toBe(0);
+        });
+    });
+    // ===== Step 7: 验证 Workload 不存在 =====
+    test('Step 7: 确认 Workload 已完全删除', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('验证 Workload 不存在', async () => {
+            const workload = tensorfusionworkload(kubectl, WORKLOAD_NAME);
+            await expect(workload).toNotExistInCluster();
+        });
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/05-multi-workload-shared-gpu.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 测试场景 5: 多 Workload 共享 GPU
+ *
+ * 验证两个 TensorFusionWorkload 共享同一张 GPU 时：
+ * - 两个 workload 均可正常调度并进入 Running
+ * - GPU.status.available 资源扣减准确（两倍请求量）
+ * - GPU.status.runningApps 包含两个 workload
+ * - 删除后资源正确恢复
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/05-multi-workload-shared-gpu.ts
+ */
+export {};
+//# sourceMappingURL=05-multi-workload-shared-gpu.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/05-multi-workload-shared-gpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"05-multi-workload-shared-gpu.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/05-multi-workload-shared-gpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/plugin-kubectl/examples/tensor-fusion/05-multi-workload-shared-gpu.js

@@ -0,0 +1,145 @@
+/**
+ * 测试场景 5: 多 Workload 共享 GPU
+ *
+ * 验证两个 TensorFusionWorkload 共享同一张 GPU 时：
+ * - 两个 workload 均可正常调度并进入 Running
+ * - GPU.status.available 资源扣减准确（两倍请求量）
+ * - GPU.status.runningApps 包含两个 workload
+ * - 删除后资源正确恢复
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/05-multi-workload-shared-gpu.ts
+ */
+import { sleep } from 'bun';
+import { test, describe, expect, step, tensorfusionworkload, workloadYaml, DEFAULT_TIMEOUT, getFirstGpuName, getGpuAvailable, parseTflops, TEST_NAMESPACE, } from './_config.js';
+const WL_NAME_1 = 'tf-share-wl-1';
+const WL_NAME_2 = 'tf-share-wl-2';
+/** 每个 workload 请求的 tflops（1 TFlops = 1000m） */
+const TFLOPS_REQUEST = '1000m';
+const TFLOPS_LIMIT = '1000m';
+const VRAM_REQUEST = '1Gi';
+const VRAM_LIMIT = '1Gi';
+describe('测试场景 5: 多 Workload 共享 GPU', { record: true }, () => {
+    test('两个 TensorFusionWorkload 共享同一张 GPU 完整流程', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        let gpuName;
+        let initialTflops;
+        // ===== Step 1: 记录初始状态 =====
+        await step('获取目标 GPU 并记录初始资源', {
+            showStepTitle: false,
+            typingSpeed: 60,
+            pauseAfter: 1500,
+        }, async () => {
+            gpuName = await getFirstGpuName(kubectl);
+            const available = await getGpuAvailable(kubectl, gpuName);
+            initialTflops = available.tflops;
+            // 确认 GPU 有足够资源容纳两个 workload
+            const initialNum = parseTflops(initialTflops);
+            const requiredNum = parseTflops(TFLOPS_REQUEST) * 2;
+            expect(initialNum).toBeGreaterThanOrEqual(requiredNum);
+        });
+        // ===== Step 2: 创建两个 workload =====
+        await step('创建第一个 Workload: ' + WL_NAME_1, {
+            showStepTitle: false,
+            typingSpeed: 100,
+            pauseAfter: 2000,
+        }, async () => {
+            const yaml = workloadYaml(WL_NAME_1, {
+                tflopsRequest: TFLOPS_REQUEST,
+                tflopsLimit: TFLOPS_LIMIT,
+                vramRequest: VRAM_REQUEST,
+                vramLimit: VRAM_LIMIT,
+            });
+            const result = await kubectl.apply(yaml);
+            await expect(result).toBeSuccessful();
+        });
+        await step('创建第二个 Workload: ' + WL_NAME_2, {
+            showStepTitle: false,
+            typingSpeed: 100,
+            pauseAfter: 2000,
+        }, async () => {
+            const yaml = workloadYaml(WL_NAME_2, {
+                tflopsRequest: TFLOPS_REQUEST,
+                tflopsLimit: TFLOPS_LIMIT,
+                vramRequest: VRAM_REQUEST,
+                vramLimit: VRAM_LIMIT,
+            });
+            const result = await kubectl.apply(yaml);
+            await expect(result).toBeSuccessful();
+        });
+        // ===== Step 3: 等待两个 workload 都变为 Running =====
+        await step('等待 ' + WL_NAME_1 + ' Ready', {
+            showStepTitle: false,
+            pauseAfter: 1500,
+        }, async () => {
+            const result = await kubectl.wait('tensorfusionworkload', WL_NAME_1, 'Ready', { timeout: DEFAULT_TIMEOUT });
+            await expect(result).toBeSuccessful();
+        });
+        await step('等待 ' + WL_NAME_2 + ' Ready', {
+            showStepTitle: false,
+            pauseAfter: 1500,
+        }, async () => {
+            const result = await kubectl.wait('tensorfusionworkload', WL_NAME_2, 'Ready', { timeout: DEFAULT_TIMEOUT });
+            await expect(result).toBeSuccessful();
+        });
+        await step('验证两个 Workload 状态均为 Running', {
+            typingSpeed: 80,
+            pauseAfter: 2000,
+        }, async () => {
+            const wl1 = tensorfusionworkload(kubectl, WL_NAME_1);
+            await expect(wl1).toHaveStatusField('phase', 'Running');
+            const wl2 = tensorfusionworkload(kubectl, WL_NAME_2);
+            await expect(wl2).toHaveStatusField('phase', 'Running');
+        });
+        // ===== Step 4: 验证 GPU 可用资源扣减 =====
+        await step('检查 GPU 可用资源变化', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2500,
+        }, async () => {
+            await sleep(1000);
+            const afterAvailable = await getGpuAvailable(kubectl, gpuName);
+            const initialNum = parseTflops(initialTflops);
+            const afterNum = parseTflops(afterAvailable.tflops);
+            const expectedDeduction = parseTflops(TFLOPS_REQUEST) * 2;
+            // TFlops 应减少约 2 个 workload 的请求量
+            expect(afterNum).toBeLessThan(initialNum);
+            expect(initialNum - afterNum).toBeGreaterThanOrEqual(expectedDeduction - 100);
+            expect(initialNum - afterNum).toBeLessThanOrEqual(expectedDeduction + 100);
+        });
+        // ===== Step 5: 验证 runningApps =====
+        await step('检查 GPU runningApps 包含两个 workload', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2500,
+        }, async () => {
+            const runningApps = await kubectl.getJsonPath('gpu', gpuName, '.status.runningApps');
+            expect(runningApps).toBeDefined();
+            expect(Array.isArray(runningApps)).toBe(true);
+            const appNames = (runningApps ?? []).map(app => `${app.namespace}/${app.name}`);
+            expect(appNames).toContain(`${TEST_NAMESPACE}/${WL_NAME_1}`);
+            expect(appNames).toContain(`${TEST_NAMESPACE}/${WL_NAME_2}`);
+        });
+        // ===== Step 6: 清理 =====
+        await step('删除两个 TensorFusionWorkload', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000,
+        }, async () => {
+            const r1 = await kubectl.delete('tensorfusionworkload', WL_NAME_1);
+            await expect(r1).toBeSuccessful();
+            const r2 = await kubectl.delete('tensorfusionworkload', WL_NAME_2);
+            await expect(r2).toBeSuccessful();
+        });
+        await step('等待资源释放并验证恢复', {
+            pauseAfter: 2000,
+        }, async () => {
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            const afterRelease = await getGpuAvailable(kubectl, gpuName);
+            const releasedNum = parseTflops(afterRelease.tflops);
+            const initialNum = parseTflops(initialTflops);
+            // 允许小误差，但应接近初始值
+            expect(releasedNum).toBeGreaterThanOrEqual(initialNum - 100);
+        });
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/06-workload-resource-resize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 测试场景 6: GPU 资源调整（扩容）
+ *
+ * 基于 `GPU资源调整测试.md`：
+ * - 先创建一个已分配 GPU 资源的 TensorFusionWorkload
+ * - 记录 GPU 可用资源与 worker Pod 注解
+ * - 手动 patch workload 扩容资源
+ * - 验证 GPU 可用资源继续下降，worker 注解已更新
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/06-workload-resource-resize.ts
+ */
+export {};
+//# sourceMappingURL=06-workload-resource-resize.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/06-workload-resource-resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"06-workload-resource-resize.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/06-workload-resource-resize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/plugin-kubectl/examples/tensor-fusion/06-workload-resource-resize.js

@@ -0,0 +1,235 @@
+/**
+ * 测试场景 6: GPU 资源调整（扩容）
+ *
+ * 基于 `GPU资源调整测试.md`：
+ * - 先创建一个已分配 GPU 资源的 TensorFusionWorkload
+ * - 记录 GPU 可用资源与 worker Pod 注解
+ * - 手动 patch workload 扩容资源
+ * - 验证 GPU 可用资源继续下降，worker 注解已更新
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/06-workload-resource-resize.ts
+ */
+import { sleep } from 'bun';
+import { test, describe, expect, step, tensorfusionworkload, workloadYaml, DEFAULT_TIMEOUT, getGpuAvailable, parseTflops, } from './_config.js';
+const WORKLOAD_NAME = 'test-workload-resize';
+const INITIAL_TFLOPS = '100m';
+const INITIAL_VRAM = '8Gi';
+const TARGET_TFLOPS = '200m';
+const TARGET_VRAM = '16Gi';
+function parseResourceBytes(value) {
+    const text = String(value).trim();
+    if (!text) {
+        return 0;
+    }
+    const match = text.match(/^([0-9]+(?:\.[0-9]+)?)([a-zA-Z]+)?$/);
+    if (!match) {
+        return Number(text) || 0;
+    }
+    const num = Number(match[1]);
+    const unit = match[2] ?? '';
+    const binaryUnits = {
+        Ki: 1024,
+        Mi: 1024 ** 2,
+        Gi: 1024 ** 3,
+        Ti: 1024 ** 4,
+        Pi: 1024 ** 5,
+        Ei: 1024 ** 6,
+    };
+    const decimalUnits = {
+        K: 1000,
+        M: 1000 ** 2,
+        G: 1000 ** 3,
+        T: 1000 ** 4,
+        P: 1000 ** 5,
+        E: 1000 ** 6,
+        m: 0.001,
+    };
+    if (binaryUnits[unit] !== undefined) {
+        return num * binaryUnits[unit];
+    }
+    if (decimalUnits[unit] !== undefined) {
+        return num * decimalUnits[unit];
+    }
+    return num;
+}
+async function getWorkerPodName(kubectl, workloadName) {
+    let workerPods = await kubectl.get('pod', undefined, {
+        selector: `tensor-fusion.ai/workload=${workloadName},tensor-fusion.ai/component=worker`,
+        jqFilter: '[.items[] | {name: .metadata.name, phase: .status.phase}]',
+    });
+    if (!workerPods || workerPods.length === 0) {
+        workerPods = await kubectl.get('pod', undefined, {
+            selector: `tensor-fusion.ai/workload=${workloadName}`,
+            jqFilter: '[.items[] | {name: .metadata.name, phase: .status.phase}]',
+        });
+    }
+    if (!workerPods || workerPods.length === 0) {
+        throw new Error(`No worker pod found for workload ${workloadName}`);
+    }
+    const runningPod = workerPods.find((podInfo) => podInfo.phase === 'Running');
+    return runningPod?.name ?? workerPods[0].name;
+}
+async function getWorkerResources(kubectl, workerPodName) {
+    const data = await kubectl.get('pod', workerPodName, {
+        jqFilter: '{tflops: .metadata.annotations["tensor-fusion.ai/tflops-request"], vram: .metadata.annotations["tensor-fusion.ai/vram-request"], gpuIds: .metadata.annotations["tensor-fusion.ai/gpu-ids"]}',
+    });
+    return {
+        tflops: String(data?.tflops ?? ''),
+        vram: String(data?.vram ?? ''),
+        gpuIds: String(data?.gpuIds ?? ''),
+    };
+}
+async function resolveGpuNameFromId(kubectl, gpuId) {
+    try {
+        const direct = await kubectl.getJsonPath('gpu', gpuId, '.metadata.name');
+        if (direct) {
+            return direct;
+        }
+    }
+    catch {
+        // gpuId 不是 GPU CR 名称时，继续走 UUID 反查
+    }
+    const mapped = await kubectl.get('gpu', undefined, {
+        jqFilter: `[.items[] | select(.status.uuid == "${gpuId}")][0].metadata.name`,
+    });
+    if (!mapped || mapped === 'null') {
+        throw new Error(`Cannot resolve GPU resource name from id: ${gpuId}`);
+    }
+    return String(mapped);
+}
+describe('测试场景 6: GPU 资源调整（扩容）', { record: true }, () => {
+    test('TensorFusionWorkload 扩容后 GPU 与 worker 注解同步更新', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        let workerPodName;
+        let gpuName;
+        let beforeGpuTflops;
+        let beforeGpuVram;
+        let beforeWorkerTflops;
+        let beforeWorkerVram;
+        let afterGpuTflops;
+        let afterGpuVram;
+        let afterWorkerTflops;
+        let afterWorkerVram;
+        let beforeGpuId;
+        let afterGpuId;
+        // ===== Step 1: 创建初始 Workload 并等待就绪 =====
+        await step('创建初始 Workload（100m/8Gi）', {
+            showStepTitle: false,
+            typingSpeed: 100,
+            pauseAfter: 1800,
+        }, async () => {
+            const yaml = workloadYaml(WORKLOAD_NAME, {
+                tflopsRequest: INITIAL_TFLOPS,
+                tflopsLimit: INITIAL_TFLOPS,
+                vramRequest: INITIAL_VRAM,
+                vramLimit: INITIAL_VRAM,
+            });
+            const result = await kubectl.apply(yaml);
+            await expect(result).toBeSuccessful();
+        });
+        await step('等待 Workload Ready 并确认 Running', {
+            pauseAfter: 1800,
+        }, async () => {
+            const waitResult = await kubectl.wait('tensorfusionworkload', WORKLOAD_NAME, 'Ready', {
+                timeout: DEFAULT_TIMEOUT,
+            });
+            await expect(waitResult).toBeSuccessful();
+            const workload = tensorfusionworkload(kubectl, WORKLOAD_NAME);
+            await expect(workload).toHaveStatusField('phase', 'Running');
+        });
+        // ===== Step 2: 记录扩容前基线 =====
+        await step('记录扩容前 GPU 可用资源与 worker 注解', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000,
+        }, async () => {
+            workerPodName = await getWorkerPodName(kubectl, WORKLOAD_NAME);
+            const beforeWorker = await getWorkerResources(kubectl, workerPodName);
+            beforeWorkerTflops = beforeWorker.tflops;
+            beforeWorkerVram = beforeWorker.vram;
+            expect(beforeWorkerTflops).toBe(INITIAL_TFLOPS);
+            expect(beforeWorkerVram).toBe(INITIAL_VRAM);
+            const gpuId = beforeWorker.gpuIds.split(',')[0]?.trim();
+            expect(gpuId).toBeDefined();
+            expect(gpuId?.length ?? 0).toBeGreaterThan(0);
+            beforeGpuId = gpuId;
+            gpuName = await resolveGpuNameFromId(kubectl, beforeGpuId);
+            const beforeGpu = await getGpuAvailable(kubectl, gpuName);
+            beforeGpuTflops = beforeGpu.tflops;
+            beforeGpuVram = beforeGpu.vram;
+        });
+        // ===== Step 3: 扩容 workload 资源 =====
+        await step('patch Workload 资源到 200m/16Gi', {
+            showStepTitle: false,
+            typingSpeed: 100,
+            pauseAfter: 1800,
+        }, async () => {
+            const patchResult = await kubectl.patch('tensorfusionworkload', WORKLOAD_NAME, {
+                spec: {
+                    resources: {
+                        requests: {
+                            tflops: TARGET_TFLOPS,
+                            vram: TARGET_VRAM,
+                        },
+                        limits: {
+                            tflops: TARGET_TFLOPS,
+                            vram: TARGET_VRAM,
+                        },
+                    },
+                },
+            }, 'merge');
+            await expect(patchResult).toBeSuccessful();
+            const spec = await kubectl.getJsonPath('tensorfusionworkload', WORKLOAD_NAME, '.spec.resources');
+            expect(spec?.requests?.tflops).toBe(TARGET_TFLOPS);
+            expect(spec?.requests?.vram).toBe(TARGET_VRAM);
+        });
+        // ===== Step 4: 等待 worker 注解更新 =====
+        await step('等待 worker 注解更新为目标值', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000,
+        }, async () => {
+            const deadline = Date.now() + DEFAULT_TIMEOUT;
+            while (Date.now() < deadline) {
+                workerPodName = await getWorkerPodName(kubectl, WORKLOAD_NAME);
+                const currentWorker = await getWorkerResources(kubectl, workerPodName);
+                if (currentWorker.tflops === TARGET_TFLOPS && currentWorker.vram === TARGET_VRAM) {
+                    afterWorkerTflops = currentWorker.tflops;
+                    afterWorkerVram = currentWorker.vram;
+                    afterGpuId = currentWorker.gpuIds.split(',')[0]?.trim() ?? '';
+                    break;
+                }
+                await sleep(3000);
+            }
+            expect(afterWorkerTflops).toBe(TARGET_TFLOPS);
+            expect(afterWorkerVram).toBe(TARGET_VRAM);
+            expect(afterGpuId).toBe(beforeGpuId);
+        });
+        // ===== Step 5: 验证 GPU 可用资源进一步下降 =====
+        await step('验证 GPU 可用资源进一步减少', {
+            typingSpeed: 80,
+            pauseAfter: 2200,
+        }, async () => {
+            const afterGpu = await getGpuAvailable(kubectl, gpuName);
+            afterGpuTflops = afterGpu.tflops;
+            afterGpuVram = afterGpu.vram;
+            const beforeTflopsNum = parseTflops(beforeGpuTflops);
+            const afterTflopsNum = parseTflops(afterGpuTflops);
+            const beforeVramBytes = parseResourceBytes(beforeGpuVram);
+            const afterVramBytes = parseResourceBytes(afterGpuVram);
+            expect(afterTflopsNum).toBeLessThan(beforeTflopsNum);
+            expect(afterVramBytes).toBeLessThan(beforeVramBytes);
+        });
+        // ===== Step 6: 清理 =====
+        await step('删除 Workload 并等待资源释放', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 1800,
+        }, async () => {
+            const deleteResult = await kubectl.delete('tensorfusionworkload', WORKLOAD_NAME);
+            await expect(deleteResult).toBeSuccessful();
+            await sleep(5000);
+        });
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/07-workload-worker-pod-generation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 测试场景 7: Workload 创建和 Worker Pod 生成
+ *
+ * 基于 `Workload创建和WorkerPod生成测试.md`：
+ * - 创建 `replicas=2` 的 TensorFusionWorkload
+ * - 等待 `status.workerCount` 变为 2
+ * - 等待 worker Pod Ready
+ * - 验证 worker Pod 数量与 `spec.replicas` 一致
+ * - 验证 `status.workerCount` 正确更新
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/07-workload-worker-pod-generation.ts
+ */
+export {};
+//# sourceMappingURL=07-workload-worker-pod-generation.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/07-workload-worker-pod-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"07-workload-worker-pod-generation.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/07-workload-worker-pod-generation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}