pig-farm-controller/internal/infra/models/plan_test.go

package models_test

import (
	"sort"
	"testing"

	"git.huangwc.com/pig/pig-farm-controller/internal/infra/models"
	"github.com/stretchr/testify/assert"
)

func TestPlan_ReorderSteps(t *testing.T) {
	type testCase struct {
		name           string
		initialPlan    *models.Plan
		expectedOrders []int
	}

	testCases := []testCase{
		// --- Test Cases for Tasks ---
		{
			name: "Tasks: 完美顺序",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeTasks,
				Tasks: []models.Task{
					{ExecutionOrder: 1},
					{ExecutionOrder: 2},
					{ExecutionOrder: 3},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "Tasks: 有间断",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeTasks,
				Tasks: []models.Task{
					{ExecutionOrder: 1},
					{ExecutionOrder: 3},
					{ExecutionOrder: 5},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "Tasks: 从0开始",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeTasks,
				Tasks: []models.Task{
					{ExecutionOrder: 0},
					{ExecutionOrder: 1},
					{ExecutionOrder: 2},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "Tasks: 完全无序",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeTasks,
				Tasks: []models.Task{
					{ExecutionOrder: 8},
					{ExecutionOrder: 2},
					{ExecutionOrder: 4},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "Tasks: 包含负数",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeTasks,
				Tasks: []models.Task{
					{ExecutionOrder: -5},
					{ExecutionOrder: 10},
					{ExecutionOrder: 2},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "Tasks: 空切片",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeTasks,
				Tasks:       []models.Task{},
			},
			expectedOrders: []int{},
		},
		{
			name: "Tasks: 单个元素",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeTasks,
				Tasks: []models.Task{
					{ExecutionOrder: 100},
				},
			},
			expectedOrders: []int{1},
		},
		// --- Test Cases for SubPlans ---
		{
			name: "SubPlans: 完美顺序",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeSubPlans,
				SubPlans: []models.SubPlan{
					{ExecutionOrder: 1},
					{ExecutionOrder: 2},
					{ExecutionOrder: 3},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "SubPlans: 有间断",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeSubPlans,
				SubPlans: []models.SubPlan{
					{ExecutionOrder: 1},
					{ExecutionOrder: 3},
					{ExecutionOrder: 5},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "SubPlans: 从0开始",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeSubPlans,
				SubPlans: []models.SubPlan{
					{ExecutionOrder: 0},
					{ExecutionOrder: 1},
					{ExecutionOrder: 2},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "SubPlans: 完全无序",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeSubPlans,
				SubPlans: []models.SubPlan{
					{ExecutionOrder: 8},
					{ExecutionOrder: 2},
					{ExecutionOrder: 4},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "SubPlans: 包含负数",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeSubPlans,
				SubPlans: []models.SubPlan{
					{ExecutionOrder: -5},
					{ExecutionOrder: 10},
					{ExecutionOrder: 2},
				},
			},
			expectedOrders: []int{1, 2, 3},
		},
		{
			name: "SubPlans: 空切片",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeSubPlans,
				SubPlans:    []models.SubPlan{},
			},
			expectedOrders: []int{},
		},
		{
			name: "SubPlans: 单个元素",
			initialPlan: &models.Plan{
				ContentType: models.PlanContentTypeSubPlans,
				SubPlans: []models.SubPlan{
					{ExecutionOrder: 100},
				},
			},
			expectedOrders: []int{1},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// 调用被测试的方法
			tc.initialPlan.ReorderSteps()

			// 提取并验证最终的顺序
			finalOrders := make([]int, 0)
			if tc.initialPlan.ContentType == models.PlanContentTypeTasks {
				for _, task := range tc.initialPlan.Tasks {
					finalOrders = append(finalOrders, task.ExecutionOrder)
				}
			} else if tc.initialPlan.ContentType == models.PlanContentTypeSubPlans {
				for _, subPlan := range tc.initialPlan.SubPlans {
					finalOrders = append(finalOrders, subPlan.ExecutionOrder)
				}
			}

			// 对 finalOrders 进行排序，以确保比较的一致性，因为 ReorderSteps 后的顺序是固定的
			sort.Ints(finalOrders)

			assert.Equal(t, tc.expectedOrders, finalOrders, "The final execution orders should be a continuous sequence starting from 1.")
		})
	}
}