sap-jenkins-library/pkg/generator/helper/testdata/TestProcessMetaFiles/step_code_generated.golden

// Code generated by piper's step-generator. DO NOT EDIT.

package cmd

import (
	"fmt"
	"os"
	"path/filepath"
	"time"

	"github.com/SAP/jenkins-library/pkg/config"
	"github.com/SAP/jenkins-library/pkg/log"
	"github.com/SAP/jenkins-library/pkg/piperenv"
	"github.com/SAP/jenkins-library/pkg/telemetry"
	"github.com/SAP/jenkins-library/pkg/splunk"
	"github.com/SAP/jenkins-library/pkg/validation"
	"github.com/spf13/cobra"
)

type testStepOptions struct {
	Param0 string `json:"param0,omitempty"`
	Param1 string `json:"param1,omitempty" validate:"possible-values=value1 value2 value3"`
	Param2 string `json:"param2,omitempty" validate:"required_if=Param1 value1"`
	Param3 string `json:"param3,omitempty" validate:"possible-values=value1 value2 value3,required_if=Param1 value1 Param2 value2"`
}


type testStepCommonPipelineEnvironment struct {
	artifactVersion string
	git struct {
		commitID string
		headCommitID string
		branch string
	}
	custom struct {
		customList []string
	}
}

func (p *testStepCommonPipelineEnvironment) persist(path, resourceName string) {
	content := []struct{
		category string
		name string
		value interface{}
	}{
		{category: "", name: "artifactVersion", value: p.artifactVersion},
		{category: "git", name: "commitId", value: p.git.commitID},
		{category: "git", name: "headCommitId", value: p.git.headCommitID},
		{category: "git", name: "branch", value: p.git.branch},
		{category: "custom", name: "customList", value: p.custom.customList},
	}

	errCount := 0
	for _, param := range content {
		err := piperenv.SetResourceParameter(path, resourceName, filepath.Join(param.category, param.name), param.value)
		if err != nil {
			log.Entry().WithError(err).Error("Error persisting piper environment.")
			errCount++
		}
	}
	if errCount > 0 {
		log.Entry().Fatal("failed to persist Piper environment")
	}
}

type testStepInfluxTest struct {
	m1 struct {
		fields struct {
			f1 string
		}
		tags struct {
			t1 string
		}
	}
}

func (i *testStepInfluxTest) persist(path, resourceName string) {
	measurementContent := []struct{
		measurement string
		valType     string
		name        string
		value       interface{}
	}{
		{valType: config.InfluxField, measurement: "m1" , name: "f1", value: i.m1.fields.f1},
		{valType: config.InfluxTag, measurement: "m1" , name: "t1", value: i.m1.tags.t1},
	}

	errCount := 0
	for _, metric := range measurementContent {
		err := piperenv.SetResourceParameter(path, resourceName, filepath.Join(metric.measurement, fmt.Sprintf("%vs", metric.valType), metric.name), metric.value)
		if err != nil {
			log.Entry().WithError(err).Error("Error persisting influx environment.")
			errCount++
		}
	}
	if errCount > 0 {
		log.Entry().Fatal("failed to persist Influx environment")
	}
}


// TestStepCommand Test description
func TestStepCommand() *cobra.Command {
	const STEP_NAME = "testStep"

	metadata := testStepMetadata()
	var stepConfig testStepOptions
	var startTime time.Time
	var commonPipelineEnvironment testStepCommonPipelineEnvironment
	var influxTest testStepInfluxTest
	var logCollector *log.CollectorHook
	var splunkClient *splunk.Splunk
	telemetryClient := &telemetry.Telemetry{}

	var createTestStepCmd = &cobra.Command{
		Use:   STEP_NAME,
		Short: "Test description",
		Long: `Long Test description`,
		PreRunE: func(cmd *cobra.Command, _ []string) error {
			startTime = time.Now()
			log.SetStepName(STEP_NAME)
			log.SetVerbose(GeneralConfig.Verbose)

			GeneralConfig.GitHubAccessTokens = ResolveAccessTokens(GeneralConfig.GitHubTokens)

			path, _ := os.Getwd()
			fatalHook := &log.FatalHook{CorrelationID: GeneralConfig.CorrelationID, Path: path}
			log.RegisterHook(fatalHook)

			err := PrepareConfig(cmd, &metadata, STEP_NAME, &stepConfig, config.OpenPiperFile)
			if err != nil {
				log.SetErrorCategory(log.ErrorConfiguration)
				return err
			}

			if len(GeneralConfig.HookConfig.SentryConfig.Dsn) > 0 {
				sentryHook := log.NewSentryHook(GeneralConfig.HookConfig.SentryConfig.Dsn, GeneralConfig.CorrelationID)
				log.RegisterHook(&sentryHook)
			}

			if len(GeneralConfig.HookConfig.SplunkConfig.Dsn) > 0 {
				splunkClient = &splunk.Splunk{}
				logCollector = &log.CollectorHook{CorrelationID: GeneralConfig.CorrelationID}
				log.RegisterHook(logCollector)
			}

			validation, err := validation.New(validation.WithJSONNamesForStructFields(), validation.WithPredefinedErrorMessages())
			if err != nil {
				return err
			}
			if err = validation.ValidateStruct(stepConfig); err != nil {
				log.SetErrorCategory(log.ErrorConfiguration)
				return err
			}

			return nil
		},
		Run: func(_ *cobra.Command, _ []string) {
			stepTelemetryData := telemetry.CustomData{}
			stepTelemetryData.ErrorCode = "1"
			handler := func() {
				config.RemoveVaultSecretFiles()
				commonPipelineEnvironment.persist(GeneralConfig.EnvRootPath, "commonPipelineEnvironment")
				influxTest.persist(GeneralConfig.EnvRootPath, "influxTest")
				stepTelemetryData.Duration = fmt.Sprintf("%v", time.Since(startTime).Milliseconds())
				stepTelemetryData.ErrorCategory = log.GetErrorCategory().String()
				stepTelemetryData.PiperCommitHash = GitCommit
				telemetryClient.SetData(&stepTelemetryData)
				telemetryClient.Send()
				if len(GeneralConfig.HookConfig.SplunkConfig.Dsn) > 0 {
					splunkClient.Send(telemetryClient.GetData(), logCollector)
				}
			}
			log.DeferExitHandler(handler)
			defer handler()
			telemetryClient.Initialize(GeneralConfig.NoTelemetry, STEP_NAME)
			if len(GeneralConfig.HookConfig.SplunkConfig.Dsn) > 0 {
				splunkClient.Initialize(GeneralConfig.CorrelationID,
				GeneralConfig.HookConfig.SplunkConfig.Dsn,
				GeneralConfig.HookConfig.SplunkConfig.Token,
				GeneralConfig.HookConfig.SplunkConfig.Index,
				GeneralConfig.HookConfig.SplunkConfig.SendLogs)
			}
			testStep(stepConfig, &stepTelemetryData, &commonPipelineEnvironment, &influxTest)
			stepTelemetryData.ErrorCode = "0"
			log.Entry().Info("SUCCESS")
		},
	}

	addTestStepFlags(createTestStepCmd, &stepConfig)
	return createTestStepCmd
}

func addTestStepFlags(cmd *cobra.Command, stepConfig *testStepOptions) {
	cmd.Flags().StringVar(&stepConfig.Param0, "param0", `val0`, "param0 description")
	cmd.Flags().StringVar(&stepConfig.Param1, "param1", os.Getenv("PIPER_param1"), "param1 description")
	cmd.Flags().StringVar(&stepConfig.Param2, "param2", os.Getenv("PIPER_param2"), "param2 description")
	cmd.Flags().StringVar(&stepConfig.Param3, "param3", os.Getenv("PIPER_param3"), "param3 description")

	cmd.MarkFlagRequired("param0")
}

// retrieve step metadata
func testStepMetadata() config.StepData {
	var theMetaData = config.StepData{
		Metadata: config.StepMetadata{
			Name:    "testStep",
			Aliases: []config.Alias{{Name: "testStepAlias", Deprecated: true},},
			Description: "Test description",
		},
		Spec: config.StepSpec{
			Inputs: config.StepInputs{
				Resources: []config.StepResources{
					{Name: "stashName",Type: "stash",
					},
				},
				Parameters: []config.StepParameters{
					{
						Name:      "param0",
						ResourceRef: []config.ResourceReference{},
						Scope:     []string{"GENERAL","PARAMETERS",},
						Type:      "string",
						Mandatory: true,
						Aliases:   []config.Alias{},
						Default:   `val0`,
					},
					{
						Name:      "param1",
						ResourceRef: []config.ResourceReference{},
						Scope:     []string{"PARAMETERS",},
						Type:      "string",
						Mandatory: false,
						Aliases:   []config.Alias{},
						Default:   os.Getenv("PIPER_param1"),
					},
					{
						Name:      "param2",
						ResourceRef: []config.ResourceReference{},
						Scope:     []string{"PARAMETERS",},
						Type:      "string",
						Mandatory: false,
						Aliases:   []config.Alias{},
						Default:   os.Getenv("PIPER_param2"),
					},
					{
						Name:      "param3",
						ResourceRef: []config.ResourceReference{},
						Scope:     []string{"PARAMETERS",},
						Type:      "string",
						Mandatory: false,
						Aliases:   []config.Alias{},
						Default:   os.Getenv("PIPER_param3"),
					},
				},
			},
			Outputs: config.StepOutputs{
				Resources: []config.StepResources{
					{
						Name: "commonPipelineEnvironment",
						Type: "piperEnvironment",
						Parameters: []map[string]interface{}{
							{"Name": "artifactVersion"},
							{"Name": "git/commitId"},
							{"Name": "git/headCommitId"},
							{"Name": "git/branch"},
							{"Name": "custom/customList"},
						},
					},
					{
						Name: "influxTest",
						Type: "influx",
						Parameters: []map[string]interface{}{
							{"Name": "m1"},{"fields": []map[string]string{ {"name": "f1"}, } },{"tags": []map[string]string{ {"name": "t1"}, } },
						},
					},
				},
			},
		},
	}
	return theMetaData
}