github.com/SAP/jenkins-library@v1.362.0/pkg/versioning/versioning_test.go (about) 1 //go:build unit 2 // +build unit 3 4 package versioning 5 6 import ( 7 "net/http" 8 "testing" 9 10 "github.com/SAP/jenkins-library/pkg/mock" 11 "github.com/stretchr/testify/assert" 12 ) 13 14 type versioningMockUtils struct { 15 *mock.ExecMockRunner 16 *mock.FilesMock 17 } 18 19 func newVersioningMockUtils() *versioningMockUtils { 20 utils := versioningMockUtils{ 21 ExecMockRunner: &mock.ExecMockRunner{}, 22 FilesMock: &mock.FilesMock{}, 23 } 24 return &utils 25 } 26 27 func (v *versioningMockUtils) DownloadFile(url, filename string, header http.Header, cookies []*http.Cookie) error { 28 // so far no dedicated logic required for testing 29 return nil 30 } 31 32 func TestGetArtifact(t *testing.T) { 33 t.Run("custom", func(t *testing.T) { 34 custom, err := GetArtifact("custom", "test.ini", &Options{VersionField: "theversion", VersionSection: "test"}, nil) 35 36 assert.NoError(t, err) 37 38 theType, ok := custom.(*INIfile) 39 assert.True(t, ok) 40 assert.Equal(t, "test.ini", theType.path) 41 assert.Equal(t, "theversion", theType.versionField) 42 assert.Equal(t, "test", theType.versionSection) 43 assert.Equal(t, "semver2", custom.VersioningScheme()) 44 }) 45 46 t.Run("docker", func(t *testing.T) { 47 docker, err := GetArtifact("docker", "test.ini", &Options{VersionSource: "custom", VersionField: "theversion", VersionSection: "test"}, nil) 48 49 assert.NoError(t, err) 50 51 theType, ok := docker.(*Docker) 52 assert.True(t, ok) 53 assert.Equal(t, "test.ini", theType.path) 54 assert.Equal(t, "theversion", theType.options.VersionField) 55 assert.Equal(t, "test", theType.options.VersionSection) 56 assert.Equal(t, "docker", docker.VersioningScheme()) 57 }) 58 59 t.Run("dub", func(t *testing.T) { 60 dub, err := GetArtifact("dub", "", &Options{VersionField: "theversion"}, nil) 61 62 assert.NoError(t, err) 63 64 theType, ok := dub.(*JSONfile) 65 assert.True(t, ok) 66 assert.Equal(t, "dub.json", theType.path) 67 assert.Equal(t, "version", theType.versionField) 68 assert.Equal(t, "semver2", dub.VersioningScheme()) 69 }) 70 71 t.Run("golang - version file", func(t *testing.T) { 72 fileExists = func(s string) (bool, error) { 73 if s == "go.mod" { 74 return false, nil 75 } 76 return true, nil 77 } 78 golang, err := GetArtifact("golang", "", &Options{}, nil) 79 80 assert.NoError(t, err) 81 82 theType, ok := golang.(*Versionfile) 83 assert.True(t, ok) 84 assert.Equal(t, "VERSION", theType.path) 85 assert.Equal(t, "semver2", golang.VersioningScheme()) 86 }) 87 88 t.Run("golang - gomod", func(t *testing.T) { 89 fileExists = func(s string) (bool, error) { 90 if s == "go.mod" { 91 return true, nil 92 } 93 return false, nil 94 } 95 golang, err := GetArtifact("golang", "", &Options{}, nil) 96 97 assert.NoError(t, err) 98 99 theType, ok := golang.(*GoMod) 100 assert.True(t, ok) 101 assert.Equal(t, "go.mod", theType.path) 102 assert.Equal(t, "semver2", golang.VersioningScheme()) 103 }) 104 105 t.Run("golang - error", func(t *testing.T) { 106 fileExists = func(string) (bool, error) { return false, nil } 107 _, err := GetArtifact("golang", "", &Options{}, nil) 108 109 assert.EqualError(t, err, "no build descriptor available, supported: [go.mod VERSION version.txt]") 110 }) 111 112 t.Run("gradle", func(t *testing.T) { 113 gradle, err := GetArtifact("gradle", "", &Options{VersionField: "theversion"}, nil) 114 115 assert.NoError(t, err) 116 117 theType, ok := gradle.(*Gradle) 118 assert.True(t, ok) 119 assert.Equal(t, "gradle.properties", theType.path) 120 assert.Equal(t, "theversion", theType.versionField) 121 assert.Equal(t, "semver2", gradle.VersioningScheme()) 122 }) 123 124 t.Run("helm", func(t *testing.T) { 125 helm, err := GetArtifact("helm", "testchart/Chart.yaml", &Options{}, nil) 126 127 assert.NoError(t, err) 128 129 theType, ok := helm.(*HelmChart) 130 assert.True(t, ok) 131 assert.Equal(t, "testchart/Chart.yaml", theType.path) 132 assert.Equal(t, "semver2", helm.VersioningScheme()) 133 }) 134 135 t.Run("maven", func(t *testing.T) { 136 opts := Options{ 137 ProjectSettingsFile: "projectsettings.xml", 138 GlobalSettingsFile: "globalsettings.xml", 139 M2Path: "m2/path", 140 } 141 maven, err := GetArtifact("maven", "", &opts, nil) 142 assert.NoError(t, err) 143 144 theType, ok := maven.(*Maven) 145 assert.True(t, ok) 146 assert.Equal(t, "pom.xml", theType.options.PomPath) 147 assert.Equal(t, opts.ProjectSettingsFile, theType.options.ProjectSettingsFile) 148 assert.Equal(t, opts.GlobalSettingsFile, theType.options.GlobalSettingsFile) 149 assert.Equal(t, opts.M2Path, theType.options.M2Path) 150 assert.Equal(t, "maven", maven.VersioningScheme()) 151 }) 152 153 t.Run("CAP - maven", func(t *testing.T) { 154 opts := Options{ 155 ProjectSettingsFile: "projectsettings.xml", 156 GlobalSettingsFile: "globalsettings.xml", 157 M2Path: "m2/path", 158 CAPVersioningPreference: "maven", 159 } 160 maven, err := GetArtifact("CAP", "", &opts, nil) 161 assert.NoError(t, err) 162 163 theType, ok := maven.(*Maven) 164 assert.True(t, ok) 165 assert.Equal(t, "pom.xml", theType.options.PomPath) 166 assert.Equal(t, opts.ProjectSettingsFile, theType.options.ProjectSettingsFile) 167 assert.Equal(t, opts.GlobalSettingsFile, theType.options.GlobalSettingsFile) 168 assert.Equal(t, opts.M2Path, theType.options.M2Path) 169 assert.Equal(t, "maven", maven.VersioningScheme()) 170 }) 171 172 t.Run("mta", func(t *testing.T) { 173 mta, err := GetArtifact("mta", "", &Options{VersionField: "theversion"}, nil) 174 175 assert.NoError(t, err) 176 177 theType, ok := mta.(*YAMLfile) 178 assert.True(t, ok) 179 assert.Equal(t, "mta.yaml", theType.path) 180 assert.Equal(t, "version", theType.versionField) 181 assert.Equal(t, "semver2", mta.VersioningScheme()) 182 }) 183 184 t.Run("npm", func(t *testing.T) { 185 npm, err := GetArtifact("npm", "", &Options{VersionField: "theversion"}, nil) 186 187 assert.NoError(t, err) 188 189 theType, ok := npm.(*JSONfile) 190 assert.True(t, ok) 191 assert.Equal(t, "package.json", theType.path) 192 assert.Equal(t, "version", theType.versionField) 193 assert.Equal(t, "semver2", npm.VersioningScheme()) 194 }) 195 196 t.Run("CAP - npm", func(t *testing.T) { 197 npm, err := GetArtifact("CAP", "", &Options{VersionField: "theversion", CAPVersioningPreference: "npm"}, nil) 198 assert.NoError(t, err) 199 200 theType, ok := npm.(*JSONfile) 201 assert.True(t, ok) 202 assert.Equal(t, "package.json", theType.path) 203 assert.Equal(t, "version", theType.versionField) 204 assert.Equal(t, "semver2", npm.VersioningScheme()) 205 }) 206 207 t.Run("yarn", func(t *testing.T) { 208 npm, err := GetArtifact("yarn", "", &Options{VersionField: "theversion"}, nil) 209 210 assert.NoError(t, err) 211 212 theType, ok := npm.(*JSONfile) 213 assert.True(t, ok) 214 assert.Equal(t, "package.json", theType.path) 215 assert.Equal(t, "version", theType.versionField) 216 assert.Equal(t, "semver2", npm.VersioningScheme()) 217 }) 218 219 t.Run("pip", func(t *testing.T) { 220 fileExists = func(string) (bool, error) { return true, nil } 221 pip, err := GetArtifact("pip", "", &Options{}, nil) 222 223 assert.NoError(t, err) 224 225 theType, ok := pip.(*Pip) 226 assert.True(t, ok) 227 assert.Equal(t, "setup.py", theType.path) 228 assert.Equal(t, "pep440", pip.VersioningScheme()) 229 }) 230 231 t.Run("pip - error", func(t *testing.T) { 232 fileExists = func(string) (bool, error) { return false, nil } 233 _, err := GetArtifact("pip", "", &Options{}, nil) 234 235 assert.EqualError(t, err, "no build descriptor available, supported: [setup.py version.txt VERSION]") 236 }) 237 238 t.Run("sbt", func(t *testing.T) { 239 fileExists = func(string) (bool, error) { return true, nil } 240 sbt, err := GetArtifact("sbt", "", &Options{VersionField: "theversion"}, nil) 241 242 assert.NoError(t, err) 243 244 theType, ok := sbt.(*JSONfile) 245 assert.True(t, ok) 246 assert.Equal(t, "sbtDescriptor.json", theType.path) 247 assert.Equal(t, "version", theType.versionField) 248 assert.Equal(t, "semver2", sbt.VersioningScheme()) 249 }) 250 251 t.Run("not supported build tool", func(t *testing.T) { 252 _, err := GetArtifact("nosupport", "whatever", &Options{}, nil) 253 assert.EqualError(t, err, "build tool 'nosupport' not supported") 254 }) 255 } 256 257 func TestCustomArtifact(t *testing.T) { 258 tt := []struct { 259 file string 260 field string 261 section string 262 scheme string 263 expected Artifact 264 expectedErr string 265 }{ 266 {file: "not.supported", expectedErr: "file type not supported: 'not.supported'"}, 267 {file: "test.cfg", field: "testField", section: "testSection", expected: &INIfile{path: "test.cfg", versionField: "testField", versionSection: "testSection"}}, 268 {file: "test.ini", field: "testField", section: "testSection", expected: &INIfile{path: "test.ini", versionField: "testField", versionSection: "testSection"}}, 269 {file: "test.ini", field: "testField", section: "testSection", scheme: "maven", expected: &INIfile{path: "test.ini", versionField: "testField", versionSection: "testSection", versioningScheme: "maven"}}, 270 {file: "test.json", field: "testField", expected: &JSONfile{path: "test.json", versionField: "testField"}}, 271 {file: "test.yaml", field: "testField", expected: &YAMLfile{path: "test.yaml", versionField: "testField"}}, 272 {file: "test.yml", field: "testField", expected: &YAMLfile{path: "test.yml", versionField: "testField"}}, 273 {file: "test.txt", expected: &Versionfile{path: "test.txt"}}, 274 {file: "test", expected: &Versionfile{path: "test"}}, 275 {file: "test", scheme: "maven", expected: &Versionfile{path: "test", versioningScheme: "maven"}}, 276 } 277 278 for _, test := range tt { 279 t.Run(test.file, func(t *testing.T) { 280 res, err := customArtifact(test.file, test.field, test.section, test.scheme) 281 if len(test.expectedErr) == 0 { 282 assert.NoError(t, err) 283 assert.Equal(t, test.expected, res) 284 } else { 285 assert.EqualError(t, err, test.expectedErr) 286 } 287 }) 288 289 } 290 }