1
0
mirror of https://github.com/SAP/jenkins-library.git synced 2024-12-16 11:09:33 +02:00
sap-jenkins-library/pkg/documentation/generator/parameters_test.go
Kevin Stiehl e2335b7181
(documentation) fix documentation render bug (#2423)
* fix documentation render bug

* fix tests

* fix complexity
2020-11-26 07:51:43 +01:00

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>&#9746; parameter</li>", "<li>&#9746; general</li>", "<li>&#9746; steps</li>", "<li>&#9746; stages</li>"}},
{scope: []string{}, contains: []string{"<li>&#9744; parameter</li>", "<li>&#9744; general</li>", "<li>&#9744; steps</li>", "<li>&#9744; 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 />&nbsp;&nbsp;reference to: `testParam`<br />",
},
{
resourceRef: []config.ResourceReference{
{Name: "testCredentialId", Aliases: []config.Alias{}, Type: "secret", Param: "password"},
},
expected: "Jenkins credential id:<br />&nbsp;&nbsp;id: [`testCredentialId`](#testcredentialid)<br />&nbsp;&nbsp;reference to: `password`<br />",
},
{
resourceRef: []config.ResourceReference{
{Name: "testCredentialId", Aliases: []config.Alias{{Name: "alias1"}, {Name: "alias2", Deprecated: true}}, Type: "secret", Param: "password"},
},
contains: []string{"&nbsp;&nbsp;aliases:<br />", "&nbsp;&nbsp;- `alias1`<br />", "&nbsp;&nbsp;- `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)
})
}