1
0
mirror of https://github.com/SAP/jenkins-library.git synced 2024-12-12 10:55:20 +02:00
sap-jenkins-library/pkg/whitesource/scan_test.go
Jk1484 ffc931aad1
feat(golangBuild): use 'unit' build tag to include tests during test execution (#4345)
* Added unit tag as argument. Added description to runTests command. Changed code generator to have unit build tag in generated unit test files.

* Added unit build tag to all unit test files.

* added to new unit test unit build tag

* Update verify-go.yml

* small fix

---------

Co-authored-by: Muhammadali Nazarov <Muhammadali.Nazarov@acronis.com>
Co-authored-by: Christopher Fenner <26137398+CCFenner@users.noreply.github.com>
2023-05-03 21:02:11 +05:00

306 lines
9.0 KiB
Go

//go:build unit
// +build unit
package whitesource
import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestAppendScannedProjectVersion(t *testing.T) {
t.Parallel()
t.Run("single module", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err := scan.AppendScannedProjectVersion("module-a - 1")
// assert
assert.NoError(t, err)
expected := make(map[string]Project)
expected["module-a - 1"] = Project{Name: "module-a - 1"}
assert.Equal(t, expected, scan.scannedProjects)
_, exists := scan.scanTimes["module-a - 1"]
assert.True(t, exists)
})
t.Run("two modules", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err1 := scan.AppendScannedProjectVersion("module-a - 1")
err2 := scan.AppendScannedProjectVersion("module-b - 1")
// assert
assert.NoError(t, err1)
assert.NoError(t, err2)
expected := make(map[string]Project)
expected["module-a - 1"] = Project{Name: "module-a - 1"}
expected["module-b - 1"] = Project{Name: "module-b - 1"}
assert.Equal(t, expected, scan.scannedProjects)
_, exists := scan.scanTimes["module-b - 1"]
assert.True(t, exists)
})
t.Run("module without version", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err := scan.AppendScannedProjectVersion("module-a")
// assert
assert.EqualError(t, err, "projectName is expected to include the product version")
assert.Len(t, scan.scannedProjects, 0)
})
t.Run("duplicate module", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err1 := scan.AppendScannedProjectVersion("module-a - 1")
err2 := scan.AppendScannedProjectVersion("module-a - 1")
// assert
assert.NoError(t, err1)
assert.EqualError(t, err2, "project with name 'module-a - 1' was already scanned")
expected := make(map[string]Project)
expected["module-a - 1"] = Project{Name: "module-a - 1"}
assert.Equal(t, expected, scan.scannedProjects)
assert.Len(t, scan.scanTimes, 1)
})
t.Run("empty project name", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err := scan.AppendScannedProject("")
// assert
assert.EqualError(t, err, "projectName must not be empty")
assert.Len(t, scan.scannedProjects, 0)
assert.Len(t, scan.scanTimes, 0)
})
t.Run("product version supplied wrongly", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err := scan.AppendScannedProject("name - 1")
// assert
assert.EqualError(t, err, "projectName is not expected to include the product version already")
assert.Len(t, scan.scannedProjects, 0)
assert.Len(t, scan.scanTimes, 0)
})
t.Run("only version part in project name", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err := scan.AppendScannedProjectVersion(" - 1")
// assert
assert.EqualError(t, err, "projectName consists only of the product version")
assert.Len(t, scan.scannedProjects, 0)
assert.Len(t, scan.scanTimes, 0)
})
}
func TestAppendScannedProject(t *testing.T) {
t.Parallel()
t.Run("product version is appended", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
err := scan.AppendScannedProject("module-a")
// assert
assert.NoError(t, err)
expected := make(map[string]Project)
expected["module-a - 1"] = Project{Name: "module-a - 1"}
assert.Equal(t, expected, scan.scannedProjects)
})
}
func TestProjectByName(t *testing.T) {
t.Parallel()
t.Run("no init", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
project, exists := scan.ProjectByName("not there")
// assert
assert.False(t, exists)
assert.Equal(t, Project{}, project)
})
t.Run("happy path", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
err := scan.AppendScannedProject("module-a")
require.NoError(t, err)
// test
project, exists := scan.ProjectByName("module-a - 1")
// assert
assert.True(t, exists)
assert.Equal(t, Project{Name: "module-a - 1"}, project)
})
t.Run("no such project", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
err := scan.AppendScannedProject("module-a")
require.NoError(t, err)
// test
project, exists := scan.ProjectByName("not there")
// assert
assert.False(t, exists)
assert.Equal(t, Project{}, project)
})
}
func TestScannedProjects(t *testing.T) {
t.Parallel()
t.Run("no init", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
projects := scan.ScannedProjects()
// assert
assert.Len(t, projects, 0)
})
t.Run("single module", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
_ = scan.AppendScannedProject("module-a")
// test
projects := scan.ScannedProjects()
// assert
assert.Len(t, projects, 1)
assert.Contains(t, projects, Project{Name: "module-a - 1"})
})
t.Run("two modules", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
_ = scan.AppendScannedProject("module-a")
_ = scan.AppendScannedProject("module-b")
// test
projects := scan.ScannedProjects()
// assert
assert.Len(t, projects, 2)
assert.Contains(t, projects, Project{Name: "module-a - 1"})
assert.Contains(t, projects, Project{Name: "module-b - 1"})
})
}
func TestScannedProjectNames(t *testing.T) {
t.Parallel()
t.Run("empty project list", func(t *testing.T) {
scan := &Scan{ProductVersion: "1"}
assert.Equal(t, []string{}, scan.ScannedProjectNames())
})
t.Run("one project", func(t *testing.T) {
scan := &Scan{ProductVersion: "1"}
scan.AppendScannedProject("testProject1")
assert.Equal(t, []string{"testProject1 - 1"}, scan.ScannedProjectNames())
})
t.Run("multiple sorted", func(t *testing.T) {
scan := &Scan{ProductVersion: "1"}
scan.AppendScannedProject("testProject1")
scan.AppendScannedProject("testProject2")
scan.AppendScannedProject("testProject3")
assert.Equal(t, []string{"testProject1 - 1", "testProject2 - 1", "testProject3 - 1"}, scan.ScannedProjectNames())
})
t.Run("multiple mixed", func(t *testing.T) {
scan := &Scan{ProductVersion: "1"}
scan.AppendScannedProject("testProject3")
scan.AppendScannedProject("testProject1")
scan.AppendScannedProject("testProject2")
assert.Equal(t, []string{"testProject1 - 1", "testProject2 - 1", "testProject3 - 1"}, scan.ScannedProjectNames())
})
}
func TestScanTime(t *testing.T) {
t.Parallel()
t.Run("no init", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
// test
timeStamp := scan.ScanTime("module-b - 1")
// assert
assert.Equal(t, time.Time{}, timeStamp)
})
t.Run("happy path", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
_ = scan.AppendScannedProject("module-a")
// test
timeStamp := scan.ScanTime("module-a - 1")
// assert
assert.NotEqual(t, time.Time{}, timeStamp)
})
t.Run("project not scanned", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
_ = scan.AppendScannedProject("module-a")
// test
timeStamp := scan.ScanTime("module-b - 1")
// assert
assert.Equal(t, time.Time{}, timeStamp)
})
}
func TestScanUpdateProjects(t *testing.T) {
t.Parallel()
t.Run("update single project which exists", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
_ = scan.AppendScannedProject("mock-project")
mockSystem := NewSystemMock("just-now")
// test
err := scan.UpdateProjects("mock-product-token", mockSystem)
// assert
assert.NoError(t, err)
expected := make(map[string]Project)
expected["mock-project - 1"] = Project{
Name: "mock-project - 1",
ID: 42,
PluginName: "mock-plugin-name",
Token: "mock-project-token",
UploadedBy: "MrBean",
CreationDate: "last-thursday",
LastUpdateDate: "just-now",
}
assert.Equal(t, expected, scan.scannedProjects)
})
t.Run("update two projects, one of which exist", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
_ = scan.AppendScannedProject("mock-project")
_ = scan.AppendScannedProject("unknown-project")
mockSystem := NewSystemMock("just-now")
// test
err := scan.UpdateProjects("mock-product-token", mockSystem)
// assert
assert.NoError(t, err, "no error expected if not all projects exist (yet)")
expected := make(map[string]Project)
expected["mock-project - 1"] = Project{
Name: "mock-project - 1",
ID: 42,
PluginName: "mock-plugin-name",
Token: "mock-project-token",
UploadedBy: "MrBean",
CreationDate: "last-thursday",
LastUpdateDate: "just-now",
}
expected["unknown-project - 1"] = Project{
Name: "unknown-project - 1",
}
assert.Equal(t, expected, scan.scannedProjects)
})
t.Run("update single project which does not exist", func(t *testing.T) {
// init
scan := &Scan{ProductVersion: "1"}
_ = scan.AppendScannedProject("mock-project")
mockSystem := &SystemMock{} // empty mock with no products
// test
err := scan.UpdateProjects("mock-product-token", mockSystem)
// assert
assert.EqualError(t, err, "failed to retrieve WhiteSource projects meta info: no product with that token")
})
}