mirror of https://github.com/linkerd/linkerd2.git
292 lines
7.9 KiB
Go
292 lines
7.9 KiB
Go
package cmd
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
l5dcharts "github.com/linkerd/linkerd2/pkg/charts/linkerd2"
|
|
"github.com/linkerd/linkerd2/pkg/k8s"
|
|
"helm.sh/helm/v3/pkg/chart"
|
|
"helm.sh/helm/v3/pkg/chartutil"
|
|
"helm.sh/helm/v3/pkg/engine"
|
|
"sigs.k8s.io/yaml"
|
|
)
|
|
|
|
func TestRenderHelm(t *testing.T) {
|
|
// read the control plane chart and its defaults from the local folder.
|
|
// override certain defaults with pinned values.
|
|
// use the Helm lib to render the templates.
|
|
// the golden file is generated using the following `helm template` command:
|
|
// helm template --set global.identityTrustAnchorsPEM="test-crt-pem" --set identity.issuer.tls.crtPEM="test-crt-pem" --set identity.issuer.tls.keyPEM="test-key-pem" charts/linkerd2 --set identity.issuer.crtExpiry="Jul 30 17:21:14 2020" --set proxyInjector.keyPEM="test-proxy-injector-key-pem" --set proxyInjector.crtPEM="test-proxy-injector-crt-pem" --set profileValidator.keyPEM="test-profile-validator-key-pem" --set profileValidator.crtPEM="test-profile-validator-crt-pem" --set tap.keyPEM="test-tap-key-pem" --set tap.crtPEM="test-tap-crt-pem" --set global.linkerdVersion="linkerd-version" > cli/cmd/testdata/install_helm_output.golden
|
|
|
|
t.Run("Non-HA mode", func(t *testing.T) {
|
|
ha := false
|
|
chartControlPlane := chartControlPlane(t, ha, "", "111", "222")
|
|
testRenderHelm(t, chartControlPlane, "install_helm_output.golden")
|
|
})
|
|
|
|
t.Run("HA mode", func(t *testing.T) {
|
|
ha := true
|
|
chartControlPlane := chartControlPlane(t, ha, "", "111", "222")
|
|
testRenderHelm(t, chartControlPlane, "install_helm_output_ha.golden")
|
|
})
|
|
|
|
t.Run("HA mode with podLabels and podAnnotations", func(t *testing.T) {
|
|
ha := true
|
|
additionalConfig := `
|
|
global:
|
|
podLabels:
|
|
foo: bar
|
|
fiz: buz
|
|
podAnnotations:
|
|
bingo: bongo
|
|
asda: fasda
|
|
`
|
|
chartControlPlane := chartControlPlane(t, ha, additionalConfig, "333", "444")
|
|
testRenderHelm(t, chartControlPlane, "install_helm_output_ha_labels.golden")
|
|
})
|
|
|
|
t.Run("HA mode with custom namespaceSelector", func(t *testing.T) {
|
|
ha := true
|
|
additionalConfig := `
|
|
proxyInjector:
|
|
namespaceSelector:
|
|
matchExpressions:
|
|
- key: config.linkerd.io/admission-webhooks
|
|
operator: In
|
|
values:
|
|
- enabled
|
|
profileValidator:
|
|
namespaceSelector:
|
|
matchExpressions:
|
|
- key: config.linkerd.io/admission-webhooks
|
|
operator: In
|
|
values:
|
|
- enabled
|
|
`
|
|
chartControlPlane := chartControlPlane(t, ha, additionalConfig, "111", "222")
|
|
testRenderHelm(t, chartControlPlane, "install_helm_output_ha_namespace_selector.golden")
|
|
})
|
|
}
|
|
|
|
func testRenderHelm(t *testing.T, linkerd2Chart *chart.Chart, goldenFileName string) {
|
|
var (
|
|
chartName = "linkerd2"
|
|
namespace = "linkerd-dev"
|
|
)
|
|
|
|
// pin values that are changed by Helm functions on each test run
|
|
overrideJSON := `{
|
|
"global":{
|
|
"cliVersion":"",
|
|
"linkerdVersion":"linkerd-version",
|
|
"controllerImageVersion":"linkerd-version",
|
|
"identityTrustAnchorsPEM":"test-trust-anchor",
|
|
"identityTrustDomain":"test.trust.domain",
|
|
"proxy":{
|
|
"image":{
|
|
"version":"test-proxy-version"
|
|
}
|
|
},
|
|
"proxyInit":{
|
|
"image":{
|
|
"version":"test-proxy-init-version"
|
|
}
|
|
}
|
|
},
|
|
"identity":{
|
|
"issuer":{
|
|
"crtExpiry":"Jul 30 17:21:14 2020",
|
|
"crtExpiryAnnotation":"%s",
|
|
"tls":{
|
|
"keyPEM":"test-key-pem",
|
|
"crtPEM":"test-crt-pem"
|
|
}
|
|
}
|
|
},
|
|
"configs": null,
|
|
"debugContainer":{
|
|
"image":{
|
|
"version":"test-debug-version"
|
|
}
|
|
},
|
|
"proxyInjector":{
|
|
"keyPEM":"test-proxy-injector-key-pem",
|
|
"crtPEM":"test-proxy-injector-crt-pem",
|
|
"caBundle":"test-proxy-injector-ca-bundle"
|
|
},
|
|
"profileValidator":{
|
|
"keyPEM":"test-profile-validator-key-pem",
|
|
"crtPEM":"test-profile-validator-crt-pem",
|
|
"caBundle":"test-profile-validator-ca-bundle"
|
|
},
|
|
"tap":{
|
|
"keyPEM":"test-tap-key-pem",
|
|
"crtPEM":"test-tap-crt-pem",
|
|
"caBundle":"test-tap-ca-bundle"
|
|
}
|
|
}`
|
|
|
|
var overrideConfig chartutil.Values
|
|
err := yaml.Unmarshal([]byte(fmt.Sprintf(overrideJSON, k8s.IdentityIssuerExpiryAnnotation)), &overrideConfig)
|
|
if err != nil {
|
|
t.Fatal("Unexpected error", err)
|
|
}
|
|
|
|
releaseOptions := chartutil.ReleaseOptions{
|
|
Name: chartName,
|
|
Namespace: namespace,
|
|
IsUpgrade: false,
|
|
IsInstall: true,
|
|
}
|
|
|
|
valuesToRender, err := chartutil.ToRenderValues(linkerd2Chart, overrideConfig, releaseOptions, nil)
|
|
if err != nil {
|
|
t.Fatal("Unexpected error", err)
|
|
}
|
|
|
|
rendered, err := engine.Render(linkerd2Chart, valuesToRender)
|
|
if err != nil {
|
|
t.Fatal("Unexpected error", err)
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
for _, template := range linkerd2Chart.Templates {
|
|
source := chartName + "/" + template.Name
|
|
v, exists := rendered[source]
|
|
if !exists {
|
|
// skip partial templates
|
|
continue
|
|
}
|
|
buf.WriteString("---\n# Source: " + source + "\n")
|
|
buf.WriteString(v)
|
|
}
|
|
|
|
for _, dep := range linkerd2Chart.Dependencies() {
|
|
for _, template := range dep.Templates {
|
|
source := "linkerd2/charts" + "/" + dep.Metadata.Name + "/" + template.Name
|
|
v, exists := rendered[source]
|
|
if !exists {
|
|
// skip partial templates
|
|
continue
|
|
}
|
|
buf.WriteString("---\n# Source: " + source + "\n")
|
|
buf.WriteString(v)
|
|
}
|
|
}
|
|
|
|
diffTestdata(t, goldenFileName, buf.String())
|
|
}
|
|
|
|
func chartControlPlane(t *testing.T, ha bool, additionalConfig string, ignoreOutboundPorts string, ignoreInboundPorts string) *chart.Chart {
|
|
values, err := readTestValues(ha, ignoreOutboundPorts, ignoreInboundPorts)
|
|
if err != nil {
|
|
t.Fatal("Unexpected error", err)
|
|
}
|
|
|
|
if additionalConfig != "" {
|
|
err := yaml.Unmarshal([]byte(additionalConfig), values)
|
|
if err != nil {
|
|
t.Fatal("Unexpected error", err)
|
|
}
|
|
}
|
|
|
|
partialPaths := []string{
|
|
"templates/_proxy.tpl",
|
|
"templates/_proxy-init.tpl",
|
|
"templates/_volumes.tpl",
|
|
"templates/_resources.tpl",
|
|
"templates/_metadata.tpl",
|
|
"templates/_helpers.tpl",
|
|
"templates/_debug.tpl",
|
|
"templates/_trace.tpl",
|
|
"templates/_capabilities.tpl",
|
|
"templates/_affinity.tpl",
|
|
"templates/_addons.tpl",
|
|
"templates/_nodeselector.tpl",
|
|
"templates/_tolerations.tpl",
|
|
"templates/_validate.tpl",
|
|
"templates/_pull-secrets.tpl",
|
|
}
|
|
|
|
chartPartials := chartPartials(t, partialPaths)
|
|
|
|
rawValues, err := yaml.Marshal(values)
|
|
if err != nil {
|
|
t.Fatal("Unexpected error", err)
|
|
}
|
|
|
|
var mapValues chartutil.Values
|
|
err = yaml.Unmarshal(rawValues, &mapValues)
|
|
if err != nil {
|
|
t.Fatal("Unexpected error", err)
|
|
}
|
|
linkerd2Chart := &chart.Chart{
|
|
Metadata: &chart.Metadata{
|
|
Name: helmDefaultChartName,
|
|
Sources: []string{
|
|
filepath.Join("..", "..", "..", "charts", "linkerd2"),
|
|
},
|
|
},
|
|
Values: mapValues,
|
|
}
|
|
|
|
linkerd2Chart.AddDependency(chartPartials)
|
|
|
|
for _, filepath := range append(templatesConfigStage, templatesControlPlaneStage...) {
|
|
linkerd2Chart.Templates = append(linkerd2Chart.Templates, &chart.File{
|
|
Name: filepath,
|
|
})
|
|
}
|
|
|
|
for _, template := range linkerd2Chart.Templates {
|
|
filepath := filepath.Join(linkerd2Chart.Metadata.Sources[0], template.Name)
|
|
template.Data = []byte(readTestdata(t, filepath))
|
|
}
|
|
|
|
return linkerd2Chart
|
|
}
|
|
|
|
func chartPartials(t *testing.T, paths []string) *chart.Chart {
|
|
var partialTemplates []*chart.File
|
|
for _, path := range paths {
|
|
partialTemplates = append(partialTemplates, &chart.File{Name: path})
|
|
}
|
|
|
|
chart := &chart.Chart{
|
|
Metadata: &chart.Metadata{
|
|
Name: "partials",
|
|
Sources: []string{
|
|
filepath.Join("..", "..", "..", "charts", "partials"),
|
|
},
|
|
},
|
|
Templates: partialTemplates,
|
|
}
|
|
|
|
for _, template := range chart.Templates {
|
|
template := template
|
|
filepath := filepath.Join(chart.Metadata.Sources[0], template.Name)
|
|
template.Data = []byte(readTestdata(t, filepath))
|
|
}
|
|
|
|
return chart
|
|
}
|
|
|
|
func readTestValues(ha bool, ignoreOutboundPorts string, ignoreInboundPorts string) (*l5dcharts.Values, error) {
|
|
values, err := l5dcharts.NewValues()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if ha {
|
|
if err = l5dcharts.MergeHAValues(values); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
values.GetGlobal().ProxyInit.IgnoreOutboundPorts = ignoreOutboundPorts
|
|
values.GetGlobal().ProxyInit.IgnoreInboundPorts = ignoreInboundPorts
|
|
|
|
return values, nil
|
|
}
|