argo/test/workflow_test.go

package test

import (
	"git.sxidc.com/go-tools/argo-api"
	"git.sxidc.com/go-tools/argo-api/client"
	"github.com/pkg/errors"
	"gopkg.in/yaml.v3"
	"testing"
	"time"
)

func TestWorkflowBase(t *testing.T) {
	argo.Init(baseUrl, token, client.WithTimeoutSec(10))
	defer argo.Destroy()

	workflowDefinition := make(map[string]any)
	err := yaml.Unmarshal(workflowYamlStr, &workflowDefinition)
	if err != nil {
		panic(err)
	}

	err = argo.GetInstance().LintWorkflow(client.LintWorkflowParams{
		Namespace:          namespace,
		WorkflowDefinition: workflowDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	workflowName, err := argo.GetInstance().CreateWorkflow(client.CreateWorkflowParams{
		Namespace:          namespace,
		WorkflowDefinition: workflowDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	createdWorkflowDefinitions, err := argo.GetInstance().GetWorkflowsInNamespace(client.GetWorkflowsInNamespaceParams{
		Namespace: namespace,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	if len(createdWorkflowDefinitions) != 1 {
		t.Fatalf("%+v\n", errors.Errorf("数量不一致: %v", len(createdWorkflowDefinitions)))
	}

	createdWorkflowDefinition, err := argo.GetInstance().GetWorkflow(client.GetWorkflowParams{
		Namespace: namespace,
		Name:      workflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	compareDefinitionMap(t, createdWorkflowDefinition, createdWorkflowDefinitions[0])
	compareDefinitionMap(t, createdWorkflowDefinitions[0], createdWorkflowDefinition)
}

func TestSubmitWorkflow(t *testing.T) {
	argo.Init(baseUrl, token, client.WithTimeoutSec(10))
	defer argo.Destroy()

	templateDefinition := make(map[string]any)
	err := yaml.Unmarshal(workflowTemplateWithParamsYamlStr, &templateDefinition)
	if err != nil {
		panic(err)
	}

	err = argo.GetInstance().CreateWorkflowTemplate(client.CreateWorkflowTemplateParams{
		Namespace:          namespace,
		TemplateDefinition: templateDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflowTemplate(client.DeleteWorkflowTemplateParams{
			Namespace: namespace,
			Name:      workflowTemplateWithParamsName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	submitWorkflowName, err := argo.GetInstance().SubmitWorkflowFromWorkflowTemplate(client.SubmitWorkflowFromWorkflowTemplateParams{
		Namespace:    namespace,
		TemplateName: workflowTemplateWithParamsName,
		Parameters:   []string{"message=Hello Submit"},
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      submitWorkflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	submittedWorkflowDefinition, err := argo.GetInstance().GetWorkflow(client.GetWorkflowParams{
		Namespace: namespace,
		Name:      submitWorkflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	specMap := submittedWorkflowDefinition["spec"].(map[string]any)
	argumentMap := specMap["arguments"].(map[string]any)
	parametersMap := argumentMap["parameters"].([]any)

	if parametersMap[0].(map[string]any)["name"] != "message" {
		t.Fatalf("%+v\n", errors.Errorf("参数名称错误: %v", parametersMap[0].(map[string]any)["name"]))
	}

	if parametersMap[0].(map[string]any)["value"] != "Hello Submit" {
		t.Fatalf("%+v\n", errors.Errorf("参数值错误: %v", parametersMap[0].(map[string]any)["value"]))
	}
}

func TestResubmitWorkflow(t *testing.T) {
	argo.Init(baseUrl, token, client.WithTimeoutSec(10))
	defer argo.Destroy()

	workflowDefinition := make(map[string]any)
	err := yaml.Unmarshal(workflowYamlStr, &workflowDefinition)
	if err != nil {
		panic(err)
	}

	workflowName, err := argo.GetInstance().CreateWorkflow(client.CreateWorkflowParams{
		Namespace:          namespace,
		WorkflowDefinition: workflowDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	resubmittedWorkflowName, err := argo.GetInstance().ResubmitWorkflow(client.ResubmitWorkflowParams{
		Namespace: namespace,
		Name:      workflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      resubmittedWorkflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()
}

func TestRetryWorkflow(t *testing.T) {
	argo.Init(baseUrl, token, client.WithTimeoutSec(10))
	defer argo.Destroy()

	workflowDefinition := make(map[string]any)
	err := yaml.Unmarshal(workflowYamlStr, &workflowDefinition)
	if err != nil {
		panic(err)
	}

	workflowName, err := argo.GetInstance().CreateWorkflow(client.CreateWorkflowParams{
		Namespace:          namespace,
		WorkflowDefinition: workflowDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	err = argo.GetInstance().TerminateWorkflow(client.TerminateWorkflowParams{
		Namespace: namespace,
		Name:      workflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	for {
		currentWorkflowDefinitions, err := argo.GetInstance().GetWorkflow(client.GetWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}

		if currentWorkflowDefinitions["status"].(map[string]any)["phase"] != "Running" {
			break
		}

		time.Sleep(1 * time.Second)
	}

	err = argo.GetInstance().RetryWorkflow(client.RetryWorkflowParams{
		Namespace: namespace,
		Name:      workflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}
}

func TestStopWorkflow(t *testing.T) {
	argo.Init(baseUrl, token, client.WithTimeoutSec(10))
	defer argo.Destroy()

	workflowDefinition := make(map[string]any)
	err := yaml.Unmarshal(workflowYamlStr, &workflowDefinition)
	if err != nil {
		panic(err)
	}

	workflowName, err := argo.GetInstance().CreateWorkflow(client.CreateWorkflowParams{
		Namespace:          namespace,
		WorkflowDefinition: workflowDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	err = argo.GetInstance().StopWorkflow(client.StopWorkflowParams{
		Namespace: namespace,
		Name:      workflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	for {
		currentWorkflowDefinitions, err := argo.GetInstance().GetWorkflow(client.GetWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}

		if currentWorkflowDefinitions["status"].(map[string]any)["phase"] != "Running" {
			break
		}

		time.Sleep(1 * time.Second)
	}
}

func TestTerminateWorkflow(t *testing.T) {
	argo.Init(baseUrl, token, client.WithTimeoutSec(10))
	defer argo.Destroy()

	workflowDefinition := make(map[string]any)
	err := yaml.Unmarshal(workflowYamlStr, &workflowDefinition)
	if err != nil {
		panic(err)
	}

	workflowName, err := argo.GetInstance().CreateWorkflow(client.CreateWorkflowParams{
		Namespace:          namespace,
		WorkflowDefinition: workflowDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	err = argo.GetInstance().TerminateWorkflow(client.TerminateWorkflowParams{
		Namespace: namespace,
		Name:      workflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	for {
		currentWorkflowDefinitions, err := argo.GetInstance().GetWorkflow(client.GetWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}

		if currentWorkflowDefinitions["status"].(map[string]any)["phase"] != "Running" {
			break
		}

		time.Sleep(1 * time.Second)
	}
}

func TestSetWorkflow(t *testing.T) {
	argo.Init(baseUrl, token, client.WithTimeoutSec(10))
	defer argo.Destroy()

	workflowDefinition := make(map[string]any)
	err := yaml.Unmarshal(workflowYamlStr, &workflowDefinition)
	if err != nil {
		panic(err)
	}

	workflowName, err := argo.GetInstance().CreateWorkflow(client.CreateWorkflowParams{
		Namespace:          namespace,
		WorkflowDefinition: workflowDefinition,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	defer func() {
		err := argo.GetInstance().DeleteWorkflow(client.DeleteWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}
	}()

	for {
		currentWorkflowDefinitions, err := argo.GetInstance().GetWorkflow(client.GetWorkflowParams{
			Namespace: namespace,
			Name:      workflowName,
		})
		if err != nil {
			t.Fatalf("%+v\n", err)
		}

		nodes, ok := currentWorkflowDefinitions["status"].(map[string]any)["nodes"]
		if !ok {
			time.Sleep(1 * time.Second)
			continue
		}

		findA := false
		nodesMap := nodes.(map[string]any)
		for _, node := range nodesMap {
			nodeMap := node.(map[string]any)
			if nodeMap["displayName"].(string) == "A" {
				findA = true
			}
		}

		if findA {
			break
		}

		time.Sleep(1 * time.Second)
	}

	err = argo.GetInstance().SetWorkflow(client.SetWorkflowParams{
		Namespace:         namespace,
		Name:              workflowName,
		NodeFieldSelector: "displayName=A",
		OutputParameters:  `{"approve": "pass"}`,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	currentWorkflowDefinitions, err := argo.GetInstance().GetWorkflow(client.GetWorkflowParams{
		Namespace: namespace,
		Name:      workflowName,
	})
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	nodesMap := currentWorkflowDefinitions["status"].(map[string]any)["nodes"].(map[string]any)
	for _, node := range nodesMap {
		nodeMap := node.(map[string]any)
		if nodeMap["displayName"].(string) == "A" {
			outputParams := nodeMap["outputs"].(map[string]any)["parameters"].([]any)
			approveParamsMap := outputParams[0].(map[string]any)
			if approveParamsMap["name"] == "approve" && approveParamsMap["value"] == "pass" {
				return
			}

			t.Fatalf("%+v\n", errors.Errorf("输出参数不正确: %v", approveParamsMap["value"]))
		}
	}

	t.Fatalf("%+v\n", errors.New("找不到对应的节点"))
}