mirror of
https://github.com/SAP/jenkins-library.git
synced 2025-01-08 04:21:26 +02:00
84f3e10e3b
The nexus package implements uploading artifacts to a Nexus repository manager version 2 or 3 via HTTP. It also generates the MD5 and SHA1 hash files for the uploaded artifacts in the Nexus repository.
360 lines
13 KiB
Go
360 lines
13 KiB
Go
package nexus
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"testing"
|
|
|
|
piperhttp "github.com/SAP/jenkins-library/pkg/http"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestAddArtifact(t *testing.T) {
|
|
t.Run("Test valid artifact", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
err := nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "artifact.id",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "pom.xml",
|
|
})
|
|
|
|
assert.NoError(t, err, "Expected to add valid artifact")
|
|
assert.True(t, len(nexusUpload.artifacts) == 1)
|
|
|
|
assert.True(t, nexusUpload.artifacts[0].ID == "artifact.id")
|
|
assert.True(t, nexusUpload.artifacts[0].Classifier == "")
|
|
assert.True(t, nexusUpload.artifacts[0].Type == "pom")
|
|
assert.True(t, nexusUpload.artifacts[0].File == "pom.xml")
|
|
})
|
|
t.Run("Test missing ID", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
err := nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "pom.xml",
|
|
})
|
|
|
|
assert.Error(t, err, "Expected to fail adding invalid artifact")
|
|
assert.True(t, len(nexusUpload.artifacts) == 0)
|
|
})
|
|
t.Run("Test invalid ID", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
err := nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "artifact/id",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "pom.xml",
|
|
})
|
|
|
|
assert.Error(t, err, "Expected to fail adding invalid artifact")
|
|
assert.True(t, len(nexusUpload.artifacts) == 0)
|
|
})
|
|
t.Run("Test missing type", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
err := nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "artifact",
|
|
Classifier: "",
|
|
Type: "",
|
|
File: "pom.xml",
|
|
})
|
|
|
|
assert.Error(t, err, "Expected to fail adding invalid artifact")
|
|
assert.True(t, len(nexusUpload.artifacts) == 0)
|
|
})
|
|
t.Run("Test missing file", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
err := nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "artifact",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "",
|
|
})
|
|
|
|
assert.Error(t, err, "Expected to fail adding invalid artifact")
|
|
assert.True(t, len(nexusUpload.artifacts) == 0)
|
|
})
|
|
t.Run("Test adding duplicate artifact is ignored", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
_ = nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "blob",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "pom.xml",
|
|
})
|
|
err := nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "blob",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "pom.xml",
|
|
})
|
|
assert.NoError(t, err, "Expected to succeed adding duplicate artifact")
|
|
assert.True(t, len(nexusUpload.artifacts) == 1)
|
|
})
|
|
}
|
|
|
|
func TestGetArtifacts(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
err := nexusUpload.AddArtifact(ArtifactDescription{
|
|
ID: "artifact.id",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "pom.xml",
|
|
})
|
|
assert.NoError(t, err, "Expected to succeed adding valid artifact")
|
|
|
|
artifacts := nexusUpload.GetArtifacts()
|
|
// Overwrite array entry in the returned array...
|
|
artifacts[0] = ArtifactDescription{
|
|
ID: "another.id",
|
|
Classifier: "",
|
|
Type: "pom",
|
|
File: "pom.xml",
|
|
}
|
|
// ... but expect the entry in nexusUpload object to be unchanged
|
|
assert.True(t, nexusUpload.artifacts[0].ID == "artifact.id")
|
|
}
|
|
|
|
func TestGetBaseURL(t *testing.T) {
|
|
// Invalid parameters to getBaseURL() already tested via SetBaseURL() tests
|
|
t.Run("Test base URL for nexus2 is sensible", func(t *testing.T) {
|
|
baseURL, err := getBaseURL("localhost:8081/nexus", "nexus2", "maven-releases", "some.group.id")
|
|
assert.NoError(t, err, "Expected getBaseURL() to succeed")
|
|
assert.Equal(t, "localhost:8081/nexus/content/repositories/maven-releases/some/group/id/", baseURL)
|
|
})
|
|
t.Run("Test base URL for nexus3 is sensible", func(t *testing.T) {
|
|
baseURL, err := getBaseURL("localhost:8081", "nexus3", "maven-releases", "some.group.id")
|
|
assert.NoError(t, err, "Expected getBaseURL() to succeed")
|
|
assert.Equal(t, "localhost:8081/repository/maven-releases/some/group/id/", baseURL)
|
|
})
|
|
}
|
|
|
|
func TestSetBaseURL(t *testing.T) {
|
|
t.Run("Test no host provided", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("", "nexus3", "maven-releases", "some.group.id")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (no host)")
|
|
})
|
|
t.Run("Test host wrongly includes protocol http://", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("htTp://localhost:8081", "nexus3", "maven-releases", "some.group.id")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (invalid host)")
|
|
})
|
|
t.Run("Test host wrongly includes protocol https://", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("htTpS://localhost:8081", "nexus3", "maven-releases", "some.group.id")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (invalid host)")
|
|
})
|
|
t.Run("Test invalid version provided", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("localhost:8081", "3", "maven-releases", "some.group.id")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (invalid nexus version)")
|
|
})
|
|
t.Run("Test no repository provided", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("localhost:8081", "nexus3", "", "some.group.id")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (no repository)")
|
|
})
|
|
t.Run("Test no group id provided", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("localhost:8081", "nexus3", "maven-releases", "")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (no groupID)")
|
|
})
|
|
t.Run("Test no nexus version provided", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("localhost:8081", "nexus1", "maven-releases", "some.group.id")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (unsupported nexus version)")
|
|
})
|
|
t.Run("Test unsupported nexus version provided", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetBaseURL("localhost:8081", "nexus1", "maven-releases", "some.group.id")
|
|
assert.Error(t, err, "Expected SetBaseURL() to fail (unsupported nexus version)")
|
|
})
|
|
}
|
|
|
|
func TestSetArtifactsVersion(t *testing.T) {
|
|
t.Run("Test invalid artifact version", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetArtifactsVersion("")
|
|
assert.Error(t, err, "Expected SetArtifactsVersion() to fail (empty version)")
|
|
})
|
|
t.Run("Test valid artifact version", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
err := nexusUpload.SetArtifactsVersion("1.0.0-SNAPSHOT")
|
|
assert.NoError(t, err, "Expected SetArtifactsVersion() to succeed")
|
|
})
|
|
}
|
|
|
|
type simpleHttpMock struct {
|
|
responseStatus string
|
|
responseError error
|
|
}
|
|
|
|
func (m *simpleHttpMock) SendRequest(method, url string, body io.Reader, header http.Header, cookies []*http.Cookie) (*http.Response, error) {
|
|
return &http.Response{Status: m.responseStatus}, m.responseError
|
|
}
|
|
|
|
func (m *simpleHttpMock) SetOptions(options piperhttp.ClientOptions) {
|
|
}
|
|
|
|
func TestUploadNoInit(t *testing.T) {
|
|
var mockedHttp = simpleHttpMock{
|
|
responseStatus: "200 OK",
|
|
responseError: nil,
|
|
}
|
|
|
|
t.Run("Expect that upload fails without base-URL", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
|
|
err := nexusUpload.uploadArtifacts(&mockedHttp)
|
|
assert.EqualError(t, err, "the nexus.Upload needs to be configured by calling SetBaseURL() first")
|
|
})
|
|
|
|
t.Run("Expect that upload fails without version", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
_ = nexusUpload.SetBaseURL("localhost:8081", "nexus3", "maven-releases", "my.group.id")
|
|
|
|
err := nexusUpload.uploadArtifacts(&mockedHttp)
|
|
assert.EqualError(t, err, "the nexus.Upload needs to be configured by calling SetArtifactsVersion() first")
|
|
})
|
|
|
|
t.Run("Expect that upload fails without artifacts", func(t *testing.T) {
|
|
nexusUpload := Upload{}
|
|
_ = nexusUpload.SetBaseURL("localhost:8081", "nexus3", "maven-releases", "my.group.id")
|
|
_ = nexusUpload.SetArtifactsVersion("1.0")
|
|
|
|
err := nexusUpload.uploadArtifacts(&mockedHttp)
|
|
assert.EqualError(t, err, "no artifacts to upload, call AddArtifact() first")
|
|
})
|
|
}
|
|
|
|
type request struct {
|
|
method string
|
|
url string
|
|
}
|
|
|
|
type requestReply struct {
|
|
response string
|
|
err error
|
|
}
|
|
|
|
type httpMock struct {
|
|
username string
|
|
password string
|
|
requestIndex int
|
|
requestReplies []requestReply
|
|
requests []request
|
|
}
|
|
|
|
func (m *httpMock) SendRequest(method, url string, body io.Reader, header http.Header, cookies []*http.Cookie) (*http.Response, error) {
|
|
// store the request
|
|
m.requests = append(m.requests, request{method: method, url: url})
|
|
|
|
// Return the configured response for this request's index
|
|
response := m.requestReplies[m.requestIndex].response
|
|
err := m.requestReplies[m.requestIndex].err
|
|
|
|
m.requestIndex++
|
|
|
|
return &http.Response{Status: response}, err
|
|
}
|
|
|
|
func (m *httpMock) SetOptions(options piperhttp.ClientOptions) {
|
|
m.username = options.Username
|
|
m.password = options.Password
|
|
}
|
|
|
|
func (m *httpMock) appendReply(reply requestReply) {
|
|
m.requestReplies = append(m.requestReplies, reply)
|
|
}
|
|
|
|
func createConfiguredNexusUpload() Upload {
|
|
nexusUpload := Upload{}
|
|
_ = nexusUpload.SetBaseURL("localhost:8081", "nexus3", "maven-releases", "my.group.id")
|
|
_ = nexusUpload.SetArtifactsVersion("1.0")
|
|
_ = nexusUpload.AddArtifact(ArtifactDescription{ID: "artifact.id", Classifier: "", Type: "pom", File: "../../pom.xml"})
|
|
return nexusUpload
|
|
}
|
|
|
|
func TestUploadArtifacts(t *testing.T) {
|
|
t.Run("Test upload works", func(t *testing.T) {
|
|
var mockedHttp = httpMock{}
|
|
// There will be three requests, md5, sha1 and the file itself
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
|
|
nexusUpload := createConfiguredNexusUpload()
|
|
|
|
err := nexusUpload.uploadArtifacts(&mockedHttp)
|
|
assert.NoError(t, err, "Expected that uploading the artifact works")
|
|
|
|
assert.Equal(t, 3, mockedHttp.requestIndex, "Expected 3 HTTP requests")
|
|
|
|
assert.Equal(t, http.MethodPut, mockedHttp.requests[0].method)
|
|
assert.Equal(t, http.MethodPut, mockedHttp.requests[1].method)
|
|
assert.Equal(t, http.MethodPut, mockedHttp.requests[2].method)
|
|
|
|
assert.Equal(t, "http://localhost:8081/repository/maven-releases/my/group/id/artifact.id/1.0/artifact.id-1.0.pom.md5",
|
|
mockedHttp.requests[0].url)
|
|
assert.Equal(t, "http://localhost:8081/repository/maven-releases/my/group/id/artifact.id/1.0/artifact.id-1.0.pom.sha1",
|
|
mockedHttp.requests[1].url)
|
|
assert.Equal(t, "http://localhost:8081/repository/maven-releases/my/group/id/artifact.id/1.0/artifact.id-1.0.pom",
|
|
mockedHttp.requests[2].url)
|
|
})
|
|
t.Run("Test upload fails at md5 hash", func(t *testing.T) {
|
|
var mockedHttp = httpMock{}
|
|
// There will be three requests, md5, sha1 and the file itself
|
|
mockedHttp.appendReply(requestReply{response: "404 Error", err: fmt.Errorf("failed")})
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
|
|
nexusUpload := createConfiguredNexusUpload()
|
|
|
|
err := nexusUpload.uploadArtifacts(&mockedHttp)
|
|
assert.Error(t, err, "Expected that uploading the artifact failed")
|
|
|
|
assert.Equal(t, 1, mockedHttp.requestIndex, "Expected only one HTTP requests")
|
|
assert.Equal(t, 1, len(nexusUpload.artifacts), "Expected the artifact to be still present in the nexusUpload")
|
|
})
|
|
t.Run("Test upload fails at sha1 hash", func(t *testing.T) {
|
|
var mockedHttp = httpMock{}
|
|
// There will be three requests, md5, sha1 and the file itself
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
mockedHttp.appendReply(requestReply{response: "404 Error", err: fmt.Errorf("failed")})
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
|
|
nexusUpload := createConfiguredNexusUpload()
|
|
|
|
err := nexusUpload.uploadArtifacts(&mockedHttp)
|
|
assert.Error(t, err, "Expected that uploading the artifact failed")
|
|
|
|
assert.Equal(t, 2, mockedHttp.requestIndex, "Expected only two HTTP requests")
|
|
assert.Equal(t, 1, len(nexusUpload.artifacts), "Expected the artifact to be still present in the nexusUpload")
|
|
})
|
|
t.Run("Test upload fails at file", func(t *testing.T) {
|
|
var mockedHttp = httpMock{}
|
|
// There will be three requests, md5, sha1 and the file itself
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
mockedHttp.appendReply(requestReply{response: "200 OK", err: nil})
|
|
mockedHttp.appendReply(requestReply{response: "404 Error", err: fmt.Errorf("failed")})
|
|
|
|
nexusUpload := createConfiguredNexusUpload()
|
|
|
|
err := nexusUpload.uploadArtifacts(&mockedHttp)
|
|
assert.Error(t, err, "Expected that uploading the artifact failed")
|
|
|
|
assert.Equal(t, 3, mockedHttp.requestIndex, "Expected only three HTTP requests")
|
|
assert.Equal(t, 1, len(nexusUpload.artifacts), "Expected the artifact to be still present in the nexusUpload")
|
|
})
|
|
}
|