github.com/jaylevin/jenkins-library@v1.230.4/cmd/nexusUpload_test.go (about) 1 package cmd 2 3 import ( 4 "errors" 5 "fmt" 6 "github.com/SAP/jenkins-library/pkg/maven" 7 "github.com/SAP/jenkins-library/pkg/mock" 8 "github.com/SAP/jenkins-library/pkg/nexus" 9 "github.com/stretchr/testify/assert" 10 "net/http" 11 "os" 12 "path/filepath" 13 "strings" 14 "testing" 15 ) 16 17 type mockUtilsBundle struct { 18 *mock.FilesMock 19 *mock.ExecMockRunner 20 mta bool 21 maven bool 22 npm bool 23 properties map[string]map[string]string 24 cpe map[string]string 25 } 26 27 func (m *mockUtilsBundle) DownloadFile(url, filename string, header http.Header, cookies []*http.Cookie) error { 28 return errors.New("test should not download files") 29 } 30 31 func newMockUtilsBundle(usesMta, usesMaven, usesNpm bool) *mockUtilsBundle { 32 utils := mockUtilsBundle{ 33 FilesMock: &mock.FilesMock{}, 34 ExecMockRunner: &mock.ExecMockRunner{}, 35 mta: usesMta, 36 maven: usesMaven, 37 npm: usesNpm, 38 } 39 utils.properties = map[string]map[string]string{} 40 utils.cpe = map[string]string{} 41 return &utils 42 } 43 44 func (m *mockUtilsBundle) UsesMta() bool { 45 return m.mta 46 } 47 48 func (m *mockUtilsBundle) UsesMaven() bool { 49 return m.maven 50 } 51 52 func (m *mockUtilsBundle) UsesNpm() bool { 53 return m.npm 54 } 55 56 func (m *mockUtilsBundle) getEnvParameter(path, name string) string { 57 path = path + "/" + name 58 return m.cpe[path] 59 } 60 61 func (m *mockUtilsBundle) setProperty(pomFile, expression, value string) { 62 pomFile = strings.ReplaceAll(pomFile, "/", string(os.PathSeparator)) 63 pomFile = strings.ReplaceAll(pomFile, "\\", string(os.PathSeparator)) 64 65 pom := m.properties[pomFile] 66 if pom == nil { 67 pom = map[string]string{} 68 m.properties[pomFile] = pom 69 } 70 pom[expression] = value 71 } 72 73 func (m *mockUtilsBundle) evaluate(options *maven.EvaluateOptions, expression string) (string, error) { 74 pom := m.properties[options.PomPath] 75 if pom == nil { 76 return "", fmt.Errorf("pom file '%s' not found", options.PomPath) 77 } 78 value := pom[expression] 79 if value == "<empty>" { 80 return "", nil 81 } 82 if value == "" { 83 return "", fmt.Errorf("property '%s' not found in '%s'", expression, options.PomPath) 84 } 85 return value, nil 86 } 87 88 type mockUploader struct { 89 nexus.Upload 90 uploadedArtifacts []nexus.ArtifactDescription 91 } 92 93 func (m *mockUploader) Clear() { 94 // Clear is called after a successful upload. Record the artifacts that are present before 95 // they are cleared. This way we can later peek into the set of all artifacts that were 96 // uploaded across multiple bundles. 97 m.uploadedArtifacts = append(m.uploadedArtifacts, m.GetArtifacts()...) 98 m.Upload.Clear() 99 } 100 101 func createOptions() nexusUploadOptions { 102 return nexusUploadOptions{ 103 MavenRepository: "maven-releases", 104 NpmRepository: "npm-repo", 105 GroupID: "my.group.id", 106 ArtifactID: "artifact.id", 107 Version: "nexus3", 108 Url: "localhost:8081", 109 } 110 } 111 112 var testMtaYml = []byte(` 113 _schema-version: 2.1.0 114 ID: test 115 version: 0.3.0 116 117 modules: 118 119 - name: java 120 type: java 121 path: srv 122 `) 123 124 var testMtaYmlNoVersion = []byte(` 125 _schema-version: 2.1.0 126 ID: test 127 128 modules: 129 - name: java 130 type: java 131 `) 132 133 var testPomXml = []byte(` 134 <project> 135 <modelVersion>4.0.0</modelVersion> 136 <groupId>com.mycompany.app</groupId> 137 <artifactId>my-app</artifactId> 138 <version>1.0</version> 139 </project> 140 `) 141 142 var testPackageJson = []byte(`{ 143 "name": "npm-nexus-upload-test", 144 "version": "1.0.0" 145 } 146 `) 147 148 func TestUploadMTAProjects(t *testing.T) { 149 t.Parallel() 150 t.Run("Uploading MTA project without groupId parameter fails", func(t *testing.T) { 151 t.Parallel() 152 utils := newMockUtilsBundle(true, false, false) 153 utils.AddFile("mta.yaml", testMtaYml) 154 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 155 uploader := mockUploader{} 156 options := createOptions() 157 options.GroupID = "" 158 159 err := runNexusUpload(utils, &uploader, &options) 160 assert.EqualError(t, err, "the 'groupId' parameter needs to be provided for MTA projects") 161 assert.Equal(t, 0, len(uploader.GetArtifacts())) 162 assert.Equal(t, 0, len(uploader.uploadedArtifacts)) 163 }) 164 t.Run("Uploading MTA project without artifactId parameter works", func(t *testing.T) { 165 t.Parallel() 166 utils := newMockUtilsBundle(true, false, false) 167 utils.AddFile("mta.yaml", testMtaYml) 168 utils.AddFile("test.mtar", []byte("contentsOfMtar")) 169 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 170 uploader := mockUploader{} 171 options := createOptions() 172 options.ArtifactID = "" 173 174 err := runNexusUpload(utils, &uploader, &options) 175 if assert.NoError(t, err) { 176 assert.Equal(t, 2, len(uploader.uploadedArtifacts)) 177 assert.Equal(t, "test", uploader.GetArtifactsID()) 178 } 179 }) 180 t.Run("Uploading MTA project fails due to missing yaml file", func(t *testing.T) { 181 t.Parallel() 182 utils := newMockUtilsBundle(true, false, false) 183 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 184 uploader := mockUploader{} 185 options := createOptions() 186 187 err := runNexusUpload(utils, &uploader, &options) 188 assert.EqualError(t, err, "could not read from required project descriptor file 'mta.yml'") 189 assert.Equal(t, 0, len(uploader.GetArtifacts())) 190 assert.Equal(t, 0, len(uploader.uploadedArtifacts)) 191 }) 192 t.Run("Uploading MTA project fails due to garbage YAML content", func(t *testing.T) { 193 t.Parallel() 194 utils := newMockUtilsBundle(true, false, false) 195 utils.AddFile("mta.yaml", []byte("garbage")) 196 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 197 uploader := mockUploader{} 198 options := createOptions() 199 200 err := runNexusUpload(utils, &uploader, &options) 201 assert.EqualError(t, err, 202 "failed to parse contents of the project descriptor file 'mta.yaml'") 203 assert.Equal(t, 0, len(uploader.GetArtifacts())) 204 assert.Equal(t, 0, len(uploader.uploadedArtifacts)) 205 }) 206 t.Run("Uploading MTA project fails due invalid version in YAML content", func(t *testing.T) { 207 t.Parallel() 208 utils := newMockUtilsBundle(true, false, false) 209 utils.AddFile("mta.yaml", []byte(testMtaYmlNoVersion)) 210 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 211 uploader := mockUploader{} 212 options := createOptions() 213 214 err := runNexusUpload(utils, &uploader, &options) 215 assert.EqualError(t, err, 216 "the project descriptor file 'mta.yaml' has an invalid version: version must not be empty") 217 assert.Equal(t, 0, len(uploader.GetArtifacts())) 218 assert.Equal(t, 0, len(uploader.uploadedArtifacts)) 219 }) 220 t.Run("Test uploading mta.yaml project fails due to missing mtar file", func(t *testing.T) { 221 t.Parallel() 222 utils := newMockUtilsBundle(true, false, false) 223 utils.AddFile("mta.yaml", testMtaYml) 224 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 225 uploader := mockUploader{} 226 options := createOptions() 227 228 err := runNexusUpload(utils, &uploader, &options) 229 assert.EqualError(t, err, "artifact file not found 'test.mtar'") 230 231 assert.Equal(t, "0.3.0", uploader.GetArtifactsVersion()) 232 assert.Equal(t, "artifact.id", uploader.GetArtifactsID()) 233 234 // Check the artifacts that /would/ have been uploaded 235 artifacts := uploader.GetArtifacts() 236 if assert.Equal(t, 1, len(artifacts)) { 237 assert.Equal(t, "mta.yaml", artifacts[0].File) 238 assert.Equal(t, "yaml", artifacts[0].Type) 239 } 240 assert.Equal(t, 0, len(uploader.uploadedArtifacts)) 241 }) 242 t.Run("Test uploading mta.yaml project works", func(t *testing.T) { 243 t.Parallel() 244 utils := newMockUtilsBundle(true, false, false) 245 utils.AddFile("mta.yaml", testMtaYml) 246 utils.AddFile("test.mtar", []byte("contentsOfMtar")) 247 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 248 uploader := mockUploader{} 249 options := createOptions() 250 251 err := runNexusUpload(utils, &uploader, &options) 252 assert.NoError(t, err, "expected mta.yaml project upload to work") 253 254 assert.Equal(t, "0.3.0", uploader.GetArtifactsVersion()) 255 assert.Equal(t, "artifact.id", uploader.GetArtifactsID()) 256 257 artifacts := uploader.uploadedArtifacts 258 if assert.Equal(t, 2, len(artifacts)) { 259 assert.Equal(t, "mta.yaml", artifacts[0].File) 260 assert.Equal(t, "yaml", artifacts[0].Type) 261 262 assert.Equal(t, "test.mtar", artifacts[1].File) 263 assert.Equal(t, "mtar", artifacts[1].Type) 264 } 265 }) 266 t.Run("Test uploading mta.yml project works", func(t *testing.T) { 267 t.Parallel() 268 utils := newMockUtilsBundle(true, false, false) 269 utils.AddFile("mta.yml", testMtaYml) 270 utils.AddFile("test.mtar", []byte("contentsOfMtar")) 271 utils.cpe[".pipeline/commonPipelineEnvironment/mtarFilePath"] = "test.mtar" 272 uploader := mockUploader{} 273 options := createOptions() 274 275 err := runNexusUpload(utils, &uploader, &options) 276 assert.NoError(t, err, "expected mta.yml project upload to work") 277 278 assert.Equal(t, "0.3.0", uploader.GetArtifactsVersion()) 279 assert.Equal(t, "artifact.id", uploader.GetArtifactsID()) 280 281 artifacts := uploader.uploadedArtifacts 282 if assert.Equal(t, 2, len(artifacts)) { 283 assert.Equal(t, "mta.yml", artifacts[0].File) 284 assert.Equal(t, "yaml", artifacts[0].Type) 285 286 assert.Equal(t, "test.mtar", artifacts[1].File) 287 assert.Equal(t, "mtar", artifacts[1].Type) 288 } 289 }) 290 } 291 292 func TestUploadArtifacts(t *testing.T) { 293 t.Parallel() 294 t.Run("Uploading MTA project fails without info", func(t *testing.T) { 295 t.Parallel() 296 utils := newMockUtilsBundle(false, true, false) 297 uploader := mockUploader{} 298 options := createOptions() 299 300 err := uploadArtifacts(utils, &uploader, &options, false) 301 assert.EqualError(t, err, "no group ID was provided, or could be established from project files") 302 }) 303 t.Run("Uploading MTA project fails without any artifacts", func(t *testing.T) { 304 t.Parallel() 305 utils := newMockUtilsBundle(false, true, false) 306 uploader := mockUploader{} 307 options := createOptions() 308 309 _ = uploader.SetInfo(options.GroupID, "some.id", "3.0") 310 311 err := uploadArtifacts(utils, &uploader, &options, false) 312 assert.EqualError(t, err, "no artifacts to upload") 313 }) 314 t.Run("Uploading MTA project fails for unknown reasons", func(t *testing.T) { 315 t.Parallel() 316 utils := newMockUtilsBundle(false, true, false) 317 318 // Configure mocked execRunner to fail 319 utils.ShouldFailOnCommand = map[string]error{} 320 utils.ShouldFailOnCommand["mvn"] = fmt.Errorf("failed") 321 322 uploader := mockUploader{} 323 options := createOptions() 324 _ = uploader.SetInfo(options.GroupID, "some.id", "3.0") 325 _ = uploader.AddArtifact(nexus.ArtifactDescription{ 326 File: "mta.yaml", 327 Type: "yaml", 328 }) 329 _ = uploader.AddArtifact(nexus.ArtifactDescription{ 330 File: "artifact.mtar", 331 Type: "yaml", 332 }) 333 334 err := uploadArtifacts(utils, &uploader, &options, false) 335 assert.EqualError(t, err, "uploading artifacts for ID 'some.id' failed: failed to run executable, command: '[mvn -Durl=http:// -DgroupId=my.group.id -Dversion=3.0 -DartifactId=some.id -Dfile=mta.yaml -Dpackaging=yaml -DgeneratePom=false -Dfiles=artifact.mtar -Dclassifiers= -Dtypes=yaml -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn --batch-mode "+deployGoal+"]', error: failed") 336 }) 337 t.Run("Uploading bundle generates correct maven parameters", func(t *testing.T) { 338 t.Parallel() 339 utils := newMockUtilsBundle(false, true, false) 340 uploader := mockUploader{} 341 options := createOptions() 342 343 _ = uploader.SetRepoURL("localhost:8081", "nexus3", "maven-releases", "npm-repo") 344 _ = uploader.SetInfo(options.GroupID, "my.artifact", "4.0") 345 _ = uploader.AddArtifact(nexus.ArtifactDescription{ 346 File: "mta.yaml", 347 Type: "yaml", 348 }) 349 _ = uploader.AddArtifact(nexus.ArtifactDescription{ 350 File: "pom.yml", 351 Type: "pom", 352 }) 353 354 err := uploadArtifacts(utils, &uploader, &options, false) 355 assert.NoError(t, err, "expected upload as two bundles to work") 356 assert.Equal(t, 1, len(utils.Calls)) 357 358 expectedParameters1 := []string{ 359 "-Durl=http://localhost:8081/repository/maven-releases/", 360 "-DgroupId=my.group.id", 361 "-Dversion=4.0", 362 "-DartifactId=my.artifact", 363 "-Dfile=mta.yaml", 364 "-Dpackaging=yaml", 365 "-DgeneratePom=false", 366 "-Dfiles=pom.yml", 367 "-Dclassifiers=", 368 "-Dtypes=pom", 369 "-Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn", 370 "--batch-mode", 371 deployGoal} 372 assert.Equal(t, len(expectedParameters1), len(utils.Calls[0].Params)) 373 assert.Equal(t, mock.ExecCall{Exec: "mvn", Params: expectedParameters1}, utils.Calls[0]) 374 }) 375 } 376 377 func TestRunNexusUpload(t *testing.T) { 378 t.Parallel() 379 t.Run("uploading without any repos fails step", func(t *testing.T) { 380 t.Parallel() 381 utils := newMockUtilsBundle(false, false, true) 382 utils.AddFile("package.json", testPackageJson) 383 uploader := mockUploader{} 384 options := nexusUploadOptions{ 385 Url: "localhost:8081", 386 } 387 388 err := runNexusUpload(utils, &uploader, &options) 389 assert.EqualError(t, err, "none of the parameters 'mavenRepository' and 'npmRepository' are configured, or 'format' should be set if the 'url' already contains the repository ID") 390 }) 391 t.Run("Test uploading simple npm project", func(t *testing.T) { 392 t.Parallel() 393 utils := newMockUtilsBundle(false, false, true) 394 utils.AddFile("package.json", testPackageJson) 395 uploader := mockUploader{} 396 options := createOptions() 397 options.Username = "admin" 398 options.Password = "admin123" 399 400 err := runNexusUpload(utils, &uploader, &options) 401 assert.NoError(t, err, "expected npm upload to work") 402 403 assert.Equal(t, "localhost:8081/repository/npm-repo/", uploader.GetNpmRepoURL()) 404 405 assert.Equal(t, mock.ExecCall{Exec: "npm", Params: []string{"publish"}}, utils.Calls[0]) 406 assert.Equal(t, []string{"npm_config_registry=http://localhost:8081/repository/npm-repo/", "npm_config_email=project-piper@no-reply.com", "npm_config__auth=YWRtaW46YWRtaW4xMjM="}, utils.Env) 407 }) 408 } 409 410 func TestUploadMavenProjects(t *testing.T) { 411 t.Parallel() 412 t.Run("Uploading Maven project fails due to missing pom.xml", func(t *testing.T) { 413 t.Parallel() 414 utils := newMockUtilsBundle(false, true, false) 415 uploader := mockUploader{} 416 options := createOptions() 417 418 err := runNexusUpload(utils, &uploader, &options) 419 assert.EqualError(t, err, "pom.xml not found") 420 assert.Equal(t, 0, len(uploader.uploadedArtifacts)) 421 }) 422 t.Run("Test uploading Maven project with POM packaging works", func(t *testing.T) { 423 t.Parallel() 424 utils := newMockUtilsBundle(false, true, false) 425 utils.setProperty("pom.xml", "project.version", "1.0") 426 utils.setProperty("pom.xml", "project.groupId", "com.mycompany.app") 427 utils.setProperty("pom.xml", "project.artifactId", "my-app") 428 utils.setProperty("pom.xml", "project.packaging", "pom") 429 utils.setProperty("pom.xml", "project.build.finalName", "my-app-1.0") 430 utils.AddFile("pom.xml", testPomXml) 431 uploader := mockUploader{} 432 options := createOptions() 433 434 err := runNexusUpload(utils, &uploader, &options) 435 assert.NoError(t, err, "expected Maven upload to work") 436 assert.Equal(t, "1.0", uploader.GetArtifactsVersion()) 437 assert.Equal(t, "my-app", uploader.GetArtifactsID()) 438 439 artifacts := uploader.uploadedArtifacts 440 if assert.Equal(t, 1, len(artifacts)) { 441 assert.Equal(t, "pom.xml", artifacts[0].File) 442 assert.Equal(t, "pom", artifacts[0].Type) 443 } 444 }) 445 t.Run("Test uploading Maven project with JAR packaging fails without main target", func(t *testing.T) { 446 t.Parallel() 447 utils := newMockUtilsBundle(false, true, false) 448 utils.setProperty("pom.xml", "project.version", "1.0") 449 utils.setProperty("pom.xml", "project.groupId", "com.mycompany.app") 450 utils.setProperty("pom.xml", "project.artifactId", "my-app") 451 utils.setProperty("pom.xml", "project.packaging", "jar") 452 utils.setProperty("pom.xml", "project.build.finalName", "my-app-1.0") 453 utils.AddFile("pom.xml", testPomXml) 454 utils.AddDir("target") 455 uploader := mockUploader{} 456 options := createOptions() 457 458 err := runNexusUpload(utils, &uploader, &options) 459 assert.EqualError(t, err, "target artifact not found for packaging 'jar'") 460 assert.Equal(t, 0, len(uploader.uploadedArtifacts)) 461 }) 462 t.Run("Test uploading Maven project with JAR packaging works", func(t *testing.T) { 463 t.Parallel() 464 utils := newMockUtilsBundle(false, true, false) 465 utils.setProperty("pom.xml", "project.version", "1.0") 466 utils.setProperty("pom.xml", "project.groupId", "com.mycompany.app") 467 utils.setProperty("pom.xml", "project.artifactId", "my-app") 468 utils.setProperty("pom.xml", "project.packaging", "jar") 469 utils.setProperty("pom.xml", "project.build.finalName", "my-app-1.0") 470 utils.AddFile("pom.xml", testPomXml) 471 utils.AddFile(filepath.Join("target", "my-app-1.0.jar"), []byte("contentsOfJar")) 472 uploader := mockUploader{} 473 options := createOptions() 474 475 err := runNexusUpload(utils, &uploader, &options) 476 assert.NoError(t, err, "expected Maven upload to work") 477 478 assert.Equal(t, "1.0", uploader.GetArtifactsVersion()) 479 assert.Equal(t, "my-app", uploader.GetArtifactsID()) 480 481 artifacts := uploader.uploadedArtifacts 482 if assert.Equal(t, 2, len(artifacts)) { 483 assert.Equal(t, "pom.xml", artifacts[0].File) 484 assert.Equal(t, "pom", artifacts[0].Type) 485 486 assert.Equal(t, filepath.Join("target", "my-app-1.0.jar"), artifacts[1].File) 487 assert.Equal(t, "jar", artifacts[1].Type) 488 } 489 }) 490 t.Run("Test uploading Maven project with fall-back to JAR packaging works", func(t *testing.T) { 491 t.Parallel() 492 utils := newMockUtilsBundle(false, true, false) 493 utils.setProperty("pom.xml", "project.version", "1.0") 494 utils.setProperty("pom.xml", "project.groupId", "com.mycompany.app") 495 utils.setProperty("pom.xml", "project.artifactId", "my-app") 496 utils.setProperty("pom.xml", "project.packaging", "<empty>") 497 utils.setProperty("pom.xml", "project.build.finalName", "my-app-1.0") 498 utils.AddFile("pom.xml", testPomXml) 499 utils.AddFile(filepath.Join("target", "my-app-1.0.jar"), []byte("contentsOfJar")) 500 uploader := mockUploader{} 501 options := createOptions() 502 503 err := runNexusUpload(utils, &uploader, &options) 504 assert.NoError(t, err, "expected Maven upload to work") 505 assert.Equal(t, "1.0", uploader.GetArtifactsVersion()) 506 assert.Equal(t, "my-app", uploader.GetArtifactsID()) 507 508 artifacts := uploader.uploadedArtifacts 509 if assert.Equal(t, 2, len(artifacts)) { 510 assert.Equal(t, "pom.xml", artifacts[0].File) 511 assert.Equal(t, "pom", artifacts[0].Type) 512 513 assert.Equal(t, filepath.Join("target", "my-app-1.0.jar"), artifacts[1].File) 514 assert.Equal(t, "jar", artifacts[1].Type) 515 } 516 }) 517 t.Run("Test uploading Maven project with fall-back to group id from parameters works", func(t *testing.T) { 518 t.Parallel() 519 utils := newMockUtilsBundle(false, true, false) 520 utils.setProperty("pom.xml", "project.version", "1.0") 521 utils.setProperty("pom.xml", "project.artifactId", "my-app") 522 utils.setProperty("pom.xml", "project.packaging", "pom") 523 utils.setProperty("pom.xml", "project.build.finalName", "my-app-1.0") 524 utils.AddFile("pom.xml", testPomXml) 525 uploader := mockUploader{} 526 options := createOptions() 527 options.GroupID = "awesome.group" 528 529 err := runNexusUpload(utils, &uploader, &options) 530 assert.NoError(t, err, "expected Maven upload to work") 531 532 assert.Equal(t, "localhost:8081/repository/maven-releases/", 533 uploader.GetMavenRepoURL()) 534 assert.Equal(t, "1.0", uploader.GetArtifactsVersion()) 535 assert.Equal(t, "my-app", uploader.GetArtifactsID()) 536 537 artifacts := uploader.uploadedArtifacts 538 if assert.Equal(t, 1, len(artifacts)) { 539 assert.Equal(t, "pom.xml", artifacts[0].File) 540 assert.Equal(t, "pom", artifacts[0].Type) 541 } 542 }) 543 t.Run("Test uploading Maven project with fall-back for finalBuildName works", func(t *testing.T) { 544 t.Parallel() 545 utils := newMockUtilsBundle(false, true, false) 546 utils.setProperty("pom.xml", "project.version", "1.0") 547 utils.setProperty("pom.xml", "project.groupId", "awesome.group") 548 utils.setProperty("pom.xml", "project.artifactId", "my-app") 549 utils.setProperty("pom.xml", "project.packaging", "jar") 550 utils.AddFile("pom.xml", testPomXml) 551 utils.AddFile(filepath.Join("target", "my-app-1.0.jar"), []byte("contentsOfJar")) 552 uploader := mockUploader{} 553 options := createOptions() 554 555 err := runNexusUpload(utils, &uploader, &options) 556 assert.NoError(t, err, "expected Maven upload to work") 557 558 assert.Equal(t, "localhost:8081/repository/maven-releases/", 559 uploader.GetMavenRepoURL()) 560 assert.Equal(t, "1.0", uploader.GetArtifactsVersion()) 561 assert.Equal(t, "my-app", uploader.GetArtifactsID()) 562 563 artifacts := uploader.uploadedArtifacts 564 if assert.Equal(t, 2, len(artifacts)) { 565 assert.Equal(t, "pom.xml", artifacts[0].File) 566 assert.Equal(t, "pom", artifacts[0].Type) 567 assert.Equal(t, filepath.Join("target", "my-app-1.0.jar"), artifacts[1].File) 568 assert.Equal(t, "jar", artifacts[1].Type) 569 } 570 }) 571 t.Run("Test uploading Maven project with application module and finalName works", func(t *testing.T) { 572 t.Parallel() 573 utils := newMockUtilsBundle(false, true, false) 574 utils.setProperty("pom.xml", "project.version", "1.0") 575 utils.setProperty("pom.xml", "project.groupId", "com.mycompany.app") 576 utils.setProperty("pom.xml", "project.artifactId", "my-app") 577 utils.setProperty("pom.xml", "project.packaging", "pom") 578 utils.setProperty("pom.xml", "project.build.finalName", "my-app-1.0") 579 utils.setProperty("application/pom.xml", "project.version", "1.0") 580 utils.setProperty("application/pom.xml", "project.groupId", "com.mycompany.app") 581 utils.setProperty("application/pom.xml", "project.artifactId", "my-app-app") 582 utils.setProperty("application/pom.xml", "project.packaging", "war") 583 utils.setProperty("application/pom.xml", "project.build.finalName", "final-artifact") 584 utils.setProperty("integration-tests/pom.xml", "project.version", "1.0") 585 utils.setProperty("integration-tests/pom.xml", "project.groupId", "com.mycompany.app") 586 utils.setProperty("integration-tests/pom.xml", "project.artifactId", "my-app-app-integration-tests") 587 utils.setProperty("integration-tests/pom.xml", "project.packaging", "jar") 588 utils.setProperty("integration-tests/pom.xml", "project.build.finalName", "final-artifact") 589 utils.setProperty("unit-tests/pom.xml", "project.version", "1.0") 590 utils.setProperty("unit-tests/pom.xml", "project.groupId", "com.mycompany.app") 591 utils.setProperty("unit-tests/pom.xml", "project.artifactId", "my-app-app-unit-tests") 592 utils.setProperty("unit-tests/pom.xml", "project.packaging", "jar") 593 utils.setProperty("unit-tests/pom.xml", "project.build.finalName", "final-artifact") 594 utils.setProperty("performance-tests/pom.xml", "project.version", "1.0") 595 utils.setProperty("performance-tests/pom.xml", "project.groupId", "com.mycompany.app") 596 utils.setProperty("performance-tests/pom.xml", "project.artifactId", "my-app-app") 597 utils.setProperty("performance-tests/pom.xml", "project.packaging", "") 598 utils.AddFile("pom.xml", testPomXml) 599 utils.AddFile(filepath.Join("application", "pom.xml"), testPomXml) 600 utils.AddFile("application/target/final-artifact.war", []byte("contentsOfJar")) 601 utils.AddFile("application/target/final-artifact-classes.jar", []byte("contentsOfClassesJar")) 602 utils.AddFile("integration-tests/pom.xml", testPomXml) 603 utils.AddFile("integration-tests/target/final-artifact-integration-tests.jar", []byte("contentsOfJar")) 604 utils.AddFile("unit-tests/pom.xml", testPomXml) 605 utils.AddFile("unit-tests/target/final-artifact-unit-tests.jar", []byte("contentsOfJar")) 606 utils.AddFile("performance-tests/pom.xml", testPomXml) 607 uploader := mockUploader{} 608 options := createOptions() 609 610 err := runNexusUpload(utils, &uploader, &options) 611 assert.NoError(t, err, "expected upload of maven project with application module to succeed") 612 assert.Equal(t, "1.0", uploader.GetArtifactsVersion()) 613 assert.Equal(t, "my-app", uploader.GetArtifactsID()) 614 615 artifacts := uploader.uploadedArtifacts 616 if assert.Equal(t, 4, len(artifacts)) { 617 assert.Equal(t, filepath.Join("application", "pom.xml"), artifacts[0].File) 618 assert.Equal(t, "pom", artifacts[0].Type) 619 620 assert.Equal(t, filepath.Join("application", "target", "final-artifact.war"), artifacts[1].File) 621 assert.Equal(t, "war", artifacts[1].Type) 622 623 assert.Equal(t, filepath.Join("application", "target", "final-artifact-classes.jar"), artifacts[2].File) 624 assert.Equal(t, "jar", artifacts[2].Type) 625 626 assert.Equal(t, "pom.xml", artifacts[3].File) 627 assert.Equal(t, "pom", artifacts[3].Type) 628 629 } 630 if assert.Equal(t, 2, len(utils.Calls)) { 631 expectedParameters1 := []string{ 632 "-Durl=http://localhost:8081/repository/maven-releases/", 633 "-DgroupId=com.mycompany.app", 634 "-Dversion=1.0", 635 "-DartifactId=my-app-app", 636 "-Dfile=" + filepath.Join("application", "pom.xml"), 637 "-Dpackaging=pom", 638 "-Dfiles=" + filepath.Join("application", "target", "final-artifact.war") + "," + filepath.Join("application", "target", "final-artifact-classes.jar"), 639 "-Dclassifiers=,classes", 640 "-Dtypes=war,jar", 641 "-Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn", 642 "--batch-mode", 643 deployGoal} 644 assert.Equal(t, len(expectedParameters1), len(utils.Calls[0].Params)) 645 assert.Equal(t, mock.ExecCall{Exec: "mvn", Params: expectedParameters1}, utils.Calls[0]) 646 647 expectedParameters2 := []string{ 648 "-Durl=http://localhost:8081/repository/maven-releases/", 649 "-DgroupId=com.mycompany.app", 650 "-Dversion=1.0", 651 "-DartifactId=my-app", 652 "-Dfile=pom.xml", 653 "-Dpackaging=pom", 654 "-Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn", 655 "--batch-mode", 656 deployGoal} 657 assert.Equal(t, len(expectedParameters2), len(utils.Calls[1].Params)) 658 assert.Equal(t, mock.ExecCall{Exec: "mvn", Params: expectedParameters2}, utils.Calls[1]) 659 } 660 }) 661 t.Run("Write credentials settings", func(t *testing.T) { 662 t.Parallel() 663 utils := newMockUtilsBundle(false, true, false) 664 utils.setProperty("pom.xml", "project.version", "1.0") 665 utils.setProperty("pom.xml", "project.groupId", "com.mycompany.app") 666 utils.setProperty("pom.xml", "project.artifactId", "my-app") 667 utils.setProperty("pom.xml", "project.packaging", "pom") 668 utils.setProperty("pom.xml", "project.build.finalName", "my-app-1.0") 669 utils.AddFile("pom.xml", testPomXml) 670 uploader := mockUploader{} 671 options := createOptions() 672 options.Username = "admin" 673 options.Password = "admin123" 674 675 err := runNexusUpload(utils, &uploader, &options) 676 assert.NoError(t, err, "expected Maven upload to work") 677 678 assert.Equal(t, 1, len(utils.Calls)) 679 expectedParameters1 := []string{ 680 "--settings", 681 settingsPath, 682 "-Durl=http://localhost:8081/repository/maven-releases/", 683 "-DgroupId=com.mycompany.app", 684 "-Dversion=1.0", 685 "-DartifactId=my-app", 686 "-DrepositoryId=" + settingsServerID, 687 "-Dfile=pom.xml", 688 "-Dpackaging=pom", 689 "-Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn", 690 "--batch-mode", 691 deployGoal} 692 assert.Equal(t, len(expectedParameters1), len(utils.Calls[0].Params)) 693 assert.Equal(t, mock.ExecCall{Exec: "mvn", Params: expectedParameters1}, utils.Calls[0]) 694 695 expectedEnv := []string{"NEXUS_username=admin", "NEXUS_password=admin123"} 696 assert.Equal(t, 2, len(utils.Env)) 697 assert.Equal(t, expectedEnv, utils.Env) 698 699 assert.False(t, utils.HasFile(settingsPath)) 700 assert.True(t, utils.HasRemovedFile(settingsPath)) 701 }) 702 } 703 704 func TestSetupNexusCredentialsSettingsFile(t *testing.T) { 705 t.Parallel() 706 utils := newMockUtilsBundle(false, true, false) 707 options := nexusUploadOptions{Username: "admin", Password: "admin123"} 708 mavenOptions := maven.ExecuteOptions{} 709 settingsPath, err := setupNexusCredentialsSettingsFile(utils, &options, &mavenOptions) 710 711 assert.NoError(t, err, "expected setting up credentials settings.xml to work") 712 assert.Equal(t, 0, len(utils.Calls)) 713 expectedEnv := []string{"NEXUS_username=admin", "NEXUS_password=admin123"} 714 assert.Equal(t, 2, len(utils.Env)) 715 assert.Equal(t, expectedEnv, utils.Env) 716 717 assert.True(t, settingsPath != "") 718 assert.True(t, utils.HasFile(settingsPath)) 719 }