1
0
mirror of https://github.com/SAP/jenkins-library.git synced 2025-04-25 12:24:42 +02:00
sap-jenkins-library/pkg/trustengine/trustengine_test.go
Jordi van Liempt af5b738982
feat(trustengine): Integrate Trust Engine into step config resolver (#5032)
* trust engine config and handelling for vault

* add function for resolving trust engine reference

* refactor

* add basic test

* adapt to new trust engine response format

* remove accidental cyclic dependency

* move trust engine hook config

* refactor by separating code from vault

* move trust engine files to own pkg

* adapt to changes of previous commit

* log full error response of trust engine API

* enable getting multiple tokens from trustengine

* remove comment

* incorporate review comments

* go generate

* update unit tests

* apply suggested changes from code review

* fix unit tests

* add unit tests for config pkg

* make changes based on review comments

* make trust engine token available in GeneralConfig and minor fixes

* fix error logic when reading trust engine hook

* make getResponse more flexible and update logging

* update resource reference format

* improve URL handling

* improve logging

* use errors.Wrap() instead of errors.Join()

* update log messages based on suggestions

* remove trustengine resource ref from Sonar step

---------

Co-authored-by: Keshav <anil.keshav@sap.com>
Co-authored-by: jliempt <>
2024-09-11 15:20:28 +02:00

81 lines
2.6 KiB
Go

//go:build unit
// +build unit
package trustengine
import (
"fmt"
"github.com/jarcoal/httpmock"
"net/http"
"testing"
piperhttp "github.com/SAP/jenkins-library/pkg/http"
"github.com/stretchr/testify/assert"
)
const testServerURL = "https://www.project-piper.io"
const testTokenEndPoint = "tokens"
const testTokenQueryParamName = "systems"
const mockSonarToken = "mockSonarToken"
const mockblackduckToken = "mockblackduckToken"
const errorMsg403 = "unauthorized to request token"
var testFullURL = fmt.Sprintf("%s/%s?%s=", testServerURL, testTokenEndPoint, testTokenQueryParamName)
var mockSingleTokenResponse = fmt.Sprintf("{\"sonar\": \"%s\"}", mockSonarToken)
var mockTwoTokensResponse = fmt.Sprintf("{\"sonar\": \"%s\", \"blackduck\": \"%s\"}", mockSonarToken, mockblackduckToken)
var trustEngineConfiguration = Configuration{
Token: "testToken",
ServerURL: testServerURL,
TokenEndPoint: testTokenEndPoint,
TokenQueryParamName: testTokenQueryParamName,
}
func TestTrustEngine(t *testing.T) {
httpmock.Activate()
defer httpmock.DeactivateAndReset()
t.Run("Get Sonar token - happy path", func(t *testing.T) {
httpmock.RegisterResponder(http.MethodGet, testFullURL+"sonar", httpmock.NewStringResponder(200, mockSingleTokenResponse))
client := &piperhttp.Client{}
client.SetOptions(piperhttp.ClientOptions{MaxRetries: -1, UseDefaultTransport: true})
token, err := GetToken("sonar", client, trustEngineConfiguration)
assert.NoError(t, err)
assert.Equal(t, mockSonarToken, token)
})
t.Run("Get multiple tokens - happy path", func(t *testing.T) {
httpmock.RegisterResponder(http.MethodGet, testFullURL+"sonar,blackduck", httpmock.NewStringResponder(200, mockTwoTokensResponse))
client := &piperhttp.Client{}
client.SetOptions(piperhttp.ClientOptions{MaxRetries: -1, UseDefaultTransport: true})
secrets, err := GetSecrets([]string{"sonar", "blackduck"}, client, trustEngineConfiguration)
assert.NoError(t, err)
assert.Len(t, secrets, 2)
for _, s := range secrets {
switch system := s.System; system {
case "sonar":
assert.Equal(t, mockSonarToken, s.Token)
case "blackduck":
assert.Equal(t, mockblackduckToken, s.Token)
default:
continue
}
}
})
t.Run("Get Sonar token - 403 error", func(t *testing.T) {
httpmock.RegisterResponder(http.MethodGet, testFullURL+"sonar", httpmock.NewStringResponder(403, errorMsg403))
client := &piperhttp.Client{}
client.SetOptions(piperhttp.ClientOptions{MaxRetries: -1, UseDefaultTransport: true})
_, err := GetToken("sonar", client, trustEngineConfiguration)
assert.Error(t, err)
})
}