examples_test

Documentation

Index

• Variables

Variables

var ExecWithExit = &config.Executable{
	Verb:       "run",
	Name:       "exit",
	Visibility: config.VisibilityPrivate,
	Description: "This executable will exit with the provided exit code." +
		"\n\n- The exit code can be set using the `exitCode` parameter.",
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableEnvironment: config.ExecutableEnvironment{
				Args: config.ArgumentList{
					{
						EnvKey:  "exitCode",
						Default: "1",
						Type:    "int",
						Pos:     0,
					},
				},
			},
			Command: "exit $exitCode",
		},
	},
}

var ExecWithTimeout = &config.Executable{
	Verb:       "run",
	Name:       "timeout",
	Visibility: config.VisibilityPrivate,
	Description: "This executable will sleep for the provided duration." +
		"\n\n- The sleep duration can be set using the `duration` parameter.",
	Timeout: 250 * time.Millisecond,
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableEnvironment: config.ExecutableEnvironment{
				Args: config.ArgumentList{
					{
						EnvKey:  "duration",
						Default: "1",
						Type:    "int",
						Pos:     0,
					},
				},
			},
			Command: "sleep $duration",
		},
	},
}

var ParallelExec1 = &config.Executable{
	Verb:        "run",
	Name:        "parallel-exec1",
	Visibility:  config.VisibilityInternal,
	Description: "First parallel executable.",
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableDirectory: config.ExecutableDirectory{Directory: config.TmpDirLabel},
			Command:             "echo 'mkdir one;sleep 1;hello from 1;sleep 1;hello from 1'",
		},
	},
}

var ParallelExec2 = &config.Executable{
	Verb:        "run",
	Name:        "parallel-exec2",
	Visibility:  config.VisibilityInternal,
	Description: "Second parallel executable.",
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableDirectory: config.ExecutableDirectory{Directory: config.TmpDirLabel},
			Command:             "echo 'mkdir two;hello from 2;sleep 1;hello from 2'",
		},
	},
}

var ParallelExec3 = &config.Executable{
	Verb:        "run",
	Name:        "parallel-exec3",
	Visibility:  config.VisibilityInternal,
	Description: "Third parallel executable.",
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableDirectory: config.ExecutableDirectory{Directory: config.TmpDirLabel},
			Command:             "echo 'hello from 3;sleep 2;hello from 3;ls -1'",
		},
	},
}

var ParallelExecRoot = &config.Executable{
	Verb:       "start",
	Name:       "parallel",
	Visibility: config.VisibilityPrivate,
	Description: parallelBaseDesc +
		"\n\n- The environment defined on the root executable is inherited by all the child executables." +
		"\n- Setting `f:tmp` as the directory on child executables will create a shared temporary directory for execution.",
	Timeout: 10 * time.Second,
	Type: &config.ExecutableTypeSpec{
		Parallel: &config.ParallelExecutableType{
			ExecutableRefs: []config.Ref{
				"run examples:parallel-exec1",
				"run examples:parallel-exec2",
				"run examples:parallel-exec3",
			},
		},
	},
}

var ParallelExecRootWithExit = &config.Executable{
	Verb:       "start",
	Name:       "parallel-exit",
	Aliases:    []string{"parallel-with-exit"},
	Visibility: config.VisibilityPrivate,
	Description: parallelBaseDesc +
		"\n\nThe `failFast` option can be set to `true` to stop the flow if a child executable fails.",
	Timeout: 10 * time.Second,
	Type: &config.ExecutableTypeSpec{
		Parallel: &config.ParallelExecutableType{
			FailFast: true,
			ExecutableRefs: []config.Ref{
				"run examples:parallel-exec1",
				"run examples:parallel-exec2",
				"run examples:exit",
				"run examples:parallel-exec3",
			},
		},
	},
}

var ParallelExecRootWithMaxThreads = &config.Executable{
	Verb:       "start",
	Name:       "parallel-max",
	Aliases:    []string{"parallel-with-max-threads"},
	Visibility: config.VisibilityPrivate,
	Description: parallelBaseDesc +
		"\n\nThe `maxThreads` option can be set to limit the number of concurrent executions.",
	Timeout: 15 * time.Second,
	Type: &config.ExecutableTypeSpec{
		Parallel: &config.ParallelExecutableType{
			MaxThreads: 1,
			ExecutableRefs: []config.Ref{
				"run examples:parallel-exec1",
				"run examples:parallel-exec2",
				"run examples:parallel-exec3",
			},
		},
	},
}

var RequestWithBodyExec = &config.Executable{
	Verb:       "run",
	Name:       "request-with-body",
	Visibility: config.VisibilityPrivate,
	Description: requestBaseDesc +
		"\n\nThe `body` field is optional and can be used to send a request body.",
	Type: &config.ExecutableTypeSpec{
		Request: &config.RequestExecutableType{
			URL:  "https://httpbin.org/post",
			Body: `{"key": "value"}`,
		},
	},
}

var RequestWithHeadersExec = &config.Executable{
	Verb:       "run",
	Name:       "request-with-headers",
	Visibility: config.VisibilityPrivate,
	Description: requestBaseDesc +
		"\n\nThe `headers` field is optional and can be used to set custom headers.",
	Type: &config.ExecutableTypeSpec{
		Request: &config.RequestExecutableType{
			URL: "https://httpbin.org/get",
			Headers: map[string]string{
				"Authorization": "Bearer token",
				"User-Agent":    "flow",
			},
		},
	},
}

var RequestWithInvalidStatusCodeExec = &config.Executable{
	Verb:       "run",
	Name:       "request-with-invalid-status-code",
	Visibility: config.VisibilityPrivate,
	Description: requestBaseDesc +
		"\n\nThe `validStatusCodes` field is optional and can be used to specify the valid status codes.",
	Type: &config.ExecutableTypeSpec{
		Request: &config.RequestExecutableType{
			URL:              "https://httpbin.org/status/400",
			ValidStatusCodes: []int{200},
		},
	},
}

var RequestWithTimeoutExec = &config.Executable{
	Verb:       "run",
	Name:       "request-with-timeout",
	Visibility: config.VisibilityPrivate,
	Description: requestBaseDesc +
		"\n\nThe `timeout` field is optional and can be used to set the request timeout.",
	Type: &config.ExecutableTypeSpec{
		Request: &config.RequestExecutableType{
			URL:     "https://httpbin.org/delay/3",
			Timeout: 1,
		},
	},
}

var RequestWithTransformExec = &config.Executable{
	Verb:       "run",
	Name:       "request-with-transform",
	Visibility: config.VisibilityPrivate,
	Description: requestBaseDesc +
		"\n\nThe `transformResponse` field is optional and can be used to transform the response using a jq query.",
	Type: &config.ExecutableTypeSpec{
		Request: &config.RequestExecutableType{
			URL:               "https://httpbin.org/get",
			TransformResponse: ".headers",
		},
	},
}

var RequestWithValidStatusCodesExec = &config.Executable{
	Verb:       "run",
	Name:       "request-with-valid-status-codes",
	Visibility: config.VisibilityPrivate,
	Description: requestBaseDesc +
		"\n\nThe `validStatusCodes` field is optional and can be used to specify the valid status codes.",
	Type: &config.ExecutableTypeSpec{
		Request: &config.RequestExecutableType{
			URL:              "https://httpbin.org/status/200",
			ValidStatusCodes: []int{200},
		},
	},
}

var SerialExec1 = &config.Executable{
	Verb:        "run",
	Name:        "serial-exec1",
	Visibility:  config.VisibilityInternal,
	Description: "First serial executable.",
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableDirectory: config.ExecutableDirectory{Directory: config.TmpDirLabel},
			Command:             "echo 'hello from 1';mkdir one;echo $PARAM1 > one/param1.txt",
		},
	},
}

var SerialExec2 = &config.Executable{
	Verb:        "run",
	Name:        "serial-exec2",
	Visibility:  config.VisibilityInternal,
	Description: "Second serial executable.",
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableDirectory: config.ExecutableDirectory{Directory: config.TmpDirLabel},
			Command:             "echo 'hello from 2';mkdir two;echo $PARAM1 > two/param1.txt",
		},
	},
}

var SerialExec3 = &config.Executable{
	Verb:        "run",
	Name:        "serial-exec3",
	Visibility:  config.VisibilityInternal,
	Description: "Third serial executable.",
	Type: &config.ExecutableTypeSpec{
		Exec: &config.ExecExecutableType{
			ExecutableDirectory: config.ExecutableDirectory{Directory: config.TmpDirLabel},
			Command:             "echo 'hello from 3';mkdir three;echo $PARAM1 > three/param1.txt;ls -1 one two three",
		},
	},
}

var SerialExecRoot = &config.Executable{
	Verb:       "start",
	Name:       "serial",
	Visibility: config.VisibilityPrivate,
	Description: serialBaseDesc +
		"\n\n- The environment defined on the root executable is inherited by all the child executables." +
		"\n- Setting `f:tmp` as the directory on child executables will create a shared temporary directory for execution.",
	Timeout: 10 * time.Second,
	Type: &config.ExecutableTypeSpec{
		Serial: &config.SerialExecutableType{
			ExecutableEnvironment: config.ExecutableEnvironment{
				Parameters: []config.Parameter{
					{
						EnvKey: "PARAM1",
						Text:   "value1",
					},
				},
			},
			ExecutableRefs: []config.Ref{
				"run examples:serial-exec1",
				"run examples:serial-exec2",
				"run examples:serial-exec3",
			},
		},
	},
}

var SerialWithExitRoot = &config.Executable{
	Verb:       "start",
	Name:       "serial-with-exit",
	Aliases:    []string{"serial-exit"},
	Visibility: config.VisibilityPrivate,
	Description: serialBaseDesc +
		"\n\n The `failFast` option can be set to `true` to stop the flow if a child executable fails.",
	Timeout: 10 * time.Second,
	Type: &config.ExecutableTypeSpec{
		Serial: &config.SerialExecutableType{
			FailFast: true,
			ExecutableRefs: []config.Ref{
				"run examples:serial-exec1",
				"run examples:serial-exec2",
				"run examples:exit",
				"run examples:serial-exec3",
			},
		},
	},
}

var SimpleRequestExec = &config.Executable{
	Verb:       "run",
	Name:       "simple-request",
	Visibility: config.VisibilityPrivate,
	Description: requestBaseDesc +
		"\n\nThe `url` field is required and must be a valid URL." +
		"\n\nThe `method` field is optional and defaults to `GET`.",
	Type: &config.ExecutableTypeSpec{
		Request: &config.RequestExecutableType{
			URL:    "https://httpbin.org/get",
			Method: "GET",
		},
	},
}

var TestExecutableDefinition = config.ExecutableDefinition{
	Namespace:  "examples",
	Visibility: config.VisibilityInternal,
	Executables: []*config.Executable{
		ParallelExecRoot,
		ParallelExecRootWithExit,
		ParallelExecRootWithMaxThreads,
		ParallelExec1,
		ParallelExec2,
		ParallelExec3,
		SerialExecRoot,
		SerialWithExitRoot,
		SerialExec1,
		SerialExec2,
		SerialExec3,
		ExecWithExit,
	},
}

TODO: convert testdata into generated documentation