mirror of
https://github.com/SAP/jenkins-library.git
synced 2024-12-16 11:09:33 +02:00
e2335b7181
* fix documentation render bug * fix tests * fix complexity
326 lines
10 KiB
Go
326 lines
10 KiB
Go
package generator
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/SAP/jenkins-library/pkg/config"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestCreateParameterOverview(t *testing.T) {
|
|
stepData := config.StepData{
|
|
Spec: config.StepSpec{
|
|
Inputs: config.StepInputs{
|
|
Resources: []config.StepResources{
|
|
{Name: "testStash", Type: "stash"},
|
|
},
|
|
Parameters: []config.StepParameters{
|
|
{Name: "param1"},
|
|
{Name: "stashContent", Default: "testStash"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
expected := `| Name | Mandatory | Additional information |
|
|
| ---- | --------- | ---------------------- |
|
|
| [param1](#param1) | no | |
|
|
| [stashContent](#stashcontent) | no | [![Jenkins only](https://img.shields.io/badge/-Jenkins%20only-yellowgreen)](#) |
|
|
|
|
`
|
|
stepParameterNames = []string{"param1"}
|
|
assert.Equal(t, expected, createParameterOverview(&stepData))
|
|
stepParameterNames = []string{}
|
|
}
|
|
|
|
func TestParameterFurtherInfo(t *testing.T) {
|
|
tt := []struct {
|
|
paramName string
|
|
stepParams []string
|
|
stepData *config.StepData
|
|
contains string
|
|
notContains []string
|
|
}{
|
|
{paramName: "verbose", stepParams: []string{}, stepData: nil, contains: "activates debug output"},
|
|
{paramName: "script", stepParams: []string{}, stepData: nil, contains: "reference to Jenkins main pipeline script"},
|
|
{paramName: "contextTest", stepParams: []string{}, stepData: &config.StepData{}, contains: "Jenkins only", notContains: []string{"pipeline script", "id of credentials"}},
|
|
{paramName: "noop", stepParams: []string{"noop"}, stepData: &config.StepData{Spec: config.StepSpec{Inputs: config.StepInputs{Parameters: []config.StepParameters{}}}}, contains: ""},
|
|
{
|
|
paramName: "testCredentialId",
|
|
stepData: &config.StepData{
|
|
Spec: config.StepSpec{
|
|
Inputs: config.StepInputs{
|
|
Secrets: []config.StepSecrets{{Name: "testCredentialId", Type: "jenkins"}},
|
|
},
|
|
},
|
|
},
|
|
contains: "id of credentials",
|
|
},
|
|
{
|
|
paramName: "testSecret1",
|
|
stepParams: []string{"testSecret1"},
|
|
stepData: &config.StepData{
|
|
Spec: config.StepSpec{
|
|
Inputs: config.StepInputs{
|
|
Parameters: []config.StepParameters{
|
|
{Name: "testSecret1", Secret: true, ResourceRef: []config.ResourceReference{{Name: "mytestSecret", Type: "secret"}}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
contains: "credentials ([`mytestSecret`](#mytestsecret))",
|
|
},
|
|
{
|
|
paramName: "testSecret2",
|
|
stepParams: []string{"testSecret2"},
|
|
stepData: &config.StepData{
|
|
Spec: config.StepSpec{
|
|
Inputs: config.StepInputs{
|
|
Parameters: []config.StepParameters{
|
|
{Name: "testSecret2"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
contains: "",
|
|
},
|
|
}
|
|
|
|
for _, test := range tt {
|
|
stepParameterNames = test.stepParams
|
|
res := parameterFurtherInfo(test.paramName, test.stepData)
|
|
stepParameterNames = []string{}
|
|
if len(test.contains) == 0 {
|
|
assert.Equalf(t, test.contains, res, fmt.Sprintf("param %v", test.paramName))
|
|
} else {
|
|
assert.Containsf(t, res, test.contains, fmt.Sprintf("param %v", test.paramName))
|
|
}
|
|
for _, notThere := range test.notContains {
|
|
assert.NotContainsf(t, res, notThere, fmt.Sprintf("param %v", test.paramName))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreateParameterDetails(t *testing.T) {
|
|
stepData := config.StepData{
|
|
Spec: config.StepSpec{
|
|
Inputs: config.StepInputs{
|
|
Parameters: []config.StepParameters{
|
|
{
|
|
Name: "param1",
|
|
Aliases: []config.Alias{{Name: "param1Alias"}, {Name: "paramAliasDeprecated", Deprecated: true}},
|
|
Mandatory: true,
|
|
Default: "param1Default",
|
|
LongDescription: "long description",
|
|
PossibleValues: []interface{}{"val1", "val2"},
|
|
Scope: []string{"STEPS"},
|
|
Secret: true,
|
|
Type: "string",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
res := createParameterDetails(&stepData)
|
|
|
|
assert.Contains(t, res, "#### param1")
|
|
assert.Contains(t, res, "long description")
|
|
assert.Contains(t, res, "`param1Alias`")
|
|
assert.Contains(t, res, "`paramAliasDeprecated` (**deprecated**)")
|
|
assert.Contains(t, res, "string")
|
|
assert.Contains(t, res, "param1Default")
|
|
assert.Contains(t, res, "val1")
|
|
assert.Contains(t, res, "val2")
|
|
assert.Contains(t, res, "no")
|
|
assert.Contains(t, res, "**yes**")
|
|
assert.Contains(t, res, "steps")
|
|
}
|
|
|
|
func TestFormatDefault(t *testing.T) {
|
|
tt := []struct {
|
|
param config.StepParameters
|
|
stepParams []string
|
|
expected string
|
|
contains []string
|
|
}{
|
|
{param: config.StepParameters{Name: "test1"}, stepParams: []string{"test1"}, expected: "`$PIPER_test1` (if set)"},
|
|
{param: config.StepParameters{Name: "jenkins1"}, stepParams: []string{}, expected: ""},
|
|
{
|
|
param: config.StepParameters{Name: "test1", Default: []conditionDefault{{key: "key1", value: "val1", def: "def1"}, {key: "key2", value: "val2", def: "def2"}}},
|
|
stepParams: []string{"test1"},
|
|
contains: []string{"key1=`val1`: `def1`", "key2=`val2`: `def2`"},
|
|
},
|
|
{
|
|
param: config.StepParameters{Name: "test1", Default: []interface{}{conditionDefault{key: "key1", value: "val1", def: "def1"}, "def2"}},
|
|
stepParams: []string{"test1"},
|
|
contains: []string{"key1=`val1`: `def1`", "- `def2`"},
|
|
},
|
|
{
|
|
param: config.StepParameters{Name: "test1", Default: map[string]string{"key1": "def1", "key2": "def2"}},
|
|
stepParams: []string{"test1"},
|
|
contains: []string{"`key1`: `def1`", "`key2`: `def2`"},
|
|
},
|
|
{param: config.StepParameters{Name: "test1", Default: ""}, stepParams: []string{"test1"}, expected: "`''`"},
|
|
{param: config.StepParameters{Name: "test1", Default: "def1"}, stepParams: []string{"test1"}, expected: "`def1`"},
|
|
{param: config.StepParameters{Name: "test1", Default: 1}, stepParams: []string{"test1"}, expected: "`1`"},
|
|
}
|
|
|
|
for _, test := range tt {
|
|
if len(test.contains) > 0 {
|
|
res := formatDefault(test.param, test.stepParams)
|
|
for _, check := range test.contains {
|
|
assert.Contains(t, res, check)
|
|
}
|
|
|
|
} else {
|
|
assert.Equal(t, test.expected, formatDefault(test.param, test.stepParams))
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func TestAliasList(t *testing.T) {
|
|
tt := []struct {
|
|
aliases []config.Alias
|
|
expected string
|
|
contains []string
|
|
}{
|
|
{aliases: []config.Alias{}, expected: "-"},
|
|
{aliases: []config.Alias{{Name: "alias1"}}, expected: "`alias1`"},
|
|
{aliases: []config.Alias{{Name: "alias1", Deprecated: true}}, expected: "`alias1` (**deprecated**)"},
|
|
{aliases: []config.Alias{{Name: "alias1"}, {Name: "alias2", Deprecated: true}}, contains: []string{"- `alias1`", "- `alias2` (**deprecated**)"}},
|
|
}
|
|
|
|
for _, test := range tt {
|
|
if len(test.contains) > 0 {
|
|
res := aliasList(test.aliases)
|
|
for _, check := range test.contains {
|
|
assert.Contains(t, res, check)
|
|
}
|
|
} else {
|
|
assert.Equal(t, test.expected, aliasList(test.aliases))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPossibleValueList(t *testing.T) {
|
|
tt := []struct {
|
|
possibleValues []interface{}
|
|
expected string
|
|
contains []string
|
|
}{
|
|
{possibleValues: []interface{}{}, expected: ""},
|
|
{possibleValues: []interface{}{"poss1", 0}, contains: []string{"- `poss1`", "- `0`"}},
|
|
}
|
|
|
|
for _, test := range tt {
|
|
if len(test.contains) > 0 {
|
|
res := possibleValueList(test.possibleValues)
|
|
for _, check := range test.contains {
|
|
assert.Contains(t, res, check)
|
|
}
|
|
} else {
|
|
assert.Equal(t, test.expected, possibleValueList(test.possibleValues))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestScopeDetails(t *testing.T) {
|
|
tt := []struct {
|
|
scope []string
|
|
contains []string
|
|
}{
|
|
{scope: []string{"PARAMETERS", "GENERAL", "STEPS", "STAGES"}, contains: []string{"<li>☒ parameter</li>", "<li>☒ general</li>", "<li>☒ steps</li>", "<li>☒ stages</li>"}},
|
|
{scope: []string{}, contains: []string{"<li>☐ parameter</li>", "<li>☐ general</li>", "<li>☐ steps</li>", "<li>☐ stages</li>"}},
|
|
}
|
|
|
|
for _, test := range tt {
|
|
res := scopeDetails(test.scope)
|
|
|
|
for _, c := range test.contains {
|
|
assert.Contains(t, res, c)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestResourceReferenceDetails(t *testing.T) {
|
|
tt := []struct {
|
|
resourceRef []config.ResourceReference
|
|
expected string
|
|
contains []string
|
|
}{
|
|
{resourceRef: []config.ResourceReference{}, expected: "none"},
|
|
{
|
|
resourceRef: []config.ResourceReference{
|
|
{Name: "commonPipelineEnvironment", Aliases: []config.Alias{}, Type: "", Param: "testParam"},
|
|
},
|
|
expected: "_commonPipelineEnvironment_:<br /> reference to: `testParam`<br />",
|
|
},
|
|
{
|
|
resourceRef: []config.ResourceReference{
|
|
{Name: "testCredentialId", Aliases: []config.Alias{}, Type: "secret", Param: "password"},
|
|
},
|
|
expected: "Jenkins credential id:<br /> id: [`testCredentialId`](#testcredentialid)<br /> reference to: `password`<br />",
|
|
},
|
|
{
|
|
resourceRef: []config.ResourceReference{
|
|
{Name: "testCredentialId", Aliases: []config.Alias{{Name: "alias1"}, {Name: "alias2", Deprecated: true}}, Type: "secret", Param: "password"},
|
|
},
|
|
contains: []string{" aliases:<br />", " - `alias1`<br />", " - `alias2` (**Deprecated**)<br />"},
|
|
},
|
|
}
|
|
|
|
for _, test := range tt {
|
|
if len(test.contains) > 0 {
|
|
res := resourceReferenceDetails(test.resourceRef)
|
|
for _, check := range test.contains {
|
|
assert.Contains(t, res, check)
|
|
}
|
|
} else {
|
|
assert.Equal(t, test.expected, resourceReferenceDetails(test.resourceRef))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSortStepParameters(t *testing.T) {
|
|
stepData := config.StepData{
|
|
Spec: config.StepSpec{
|
|
Inputs: config.StepInputs{
|
|
Parameters: []config.StepParameters{
|
|
{Name: "ab1", Mandatory: false},
|
|
{Name: "ab3", Mandatory: true},
|
|
{Name: "ab5", Mandatory: false},
|
|
{Name: "ab6", Mandatory: true},
|
|
{Name: "ab4", Mandatory: false},
|
|
{Name: "ab2", Mandatory: true},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
t.Run("ignore mandatory", func(t *testing.T) {
|
|
sortStepParameters(&stepData, false)
|
|
|
|
assert.Equal(t, "ab1", stepData.Spec.Inputs.Parameters[0].Name)
|
|
assert.Equal(t, "ab2", stepData.Spec.Inputs.Parameters[1].Name)
|
|
assert.Equal(t, "ab3", stepData.Spec.Inputs.Parameters[2].Name)
|
|
assert.Equal(t, "ab4", stepData.Spec.Inputs.Parameters[3].Name)
|
|
assert.Equal(t, "ab5", stepData.Spec.Inputs.Parameters[4].Name)
|
|
assert.Equal(t, "ab6", stepData.Spec.Inputs.Parameters[5].Name)
|
|
})
|
|
|
|
t.Run("consider mandatory", func(t *testing.T) {
|
|
sortStepParameters(&stepData, true)
|
|
|
|
assert.Equal(t, "ab2", stepData.Spec.Inputs.Parameters[0].Name)
|
|
assert.Equal(t, "ab3", stepData.Spec.Inputs.Parameters[1].Name)
|
|
assert.Equal(t, "ab6", stepData.Spec.Inputs.Parameters[2].Name)
|
|
assert.Equal(t, "ab1", stepData.Spec.Inputs.Parameters[3].Name)
|
|
assert.Equal(t, "ab4", stepData.Spec.Inputs.Parameters[4].Name)
|
|
assert.Equal(t, "ab5", stepData.Spec.Inputs.Parameters[5].Name)
|
|
})
|
|
}
|