From f1618f8eacdef4d7e3706bef475fcf6f2b923441 Mon Sep 17 00:00:00 2001 From: mayankpande88 Date: Wed, 18 Nov 2026 15:45:55 +0530 Subject: [PATCH] feat(helm): discover releases from object labels without reading Secrets Add 'nova find --release-source labels'. It reads installed releases from the helm.sh/chart (or older chart) label and meta.helm.sh/release-* annotations on deployments, statefulsets, daemonsets, cronjobs, services and configmaps, so the service account needs no list permission on Secrets. Releases whose objects carry more than one chart label (umbrella charts) are skipped, since the parent chart cannot be recovered from labels. With no chart metadata to score on, Artifact Hub matches are limited to packages that published the installed version. The default source (secrets) is unchanged. --- CHANGELOG.md | 7 + README.md | 5 + cmd/root.go | 10 ++ pkg/helm/cluster.go | 10 ++ pkg/helm/findscore.go | 21 +++ pkg/helm/labels.go | 298 ++++++++++++++++++++++++++++++++++++++++ pkg/helm/labels_test.go | 178 ++++++++++++++++++++++++ 7 files changed, 529 insertions(+) create mode 100644 pkg/helm/labels.go create mode 100644 pkg/helm/labels_test.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 486076b..0bc4371 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,13 @@ Versions and dates above this section are from upstream and are preserved for historical context. ### Added +* `--release-source labels` on `nova find`: discovers installed Helm releases + from the `helm.sh/chart` / `chart` labels and `meta.helm.sh/release-*` + annotations on deployments, statefulsets, daemonsets, cronjobs, services and + configmaps, without reading Secrets. Releases whose objects carry more than + one chart label (umbrella charts) are skipped, and Artifact Hub matches are + limited to packages that published the installed version + (`pkg/helm/labels.go`, `pkg/helm/findscore.go`). * `RepositoryUrl` field on `ReleaseOutput` exposing the source Helm repository URL for matched releases (`pkg/output/output.go`). * `Date` field on `VersionInfo` exposing the installed release's diff --git a/README.md b/README.md index a3653ed..c0b821f 100644 --- a/README.md +++ b/README.md @@ -27,6 +27,7 @@ For the original feature documentation see the | Output | `ReleaseOutput` now includes the source Helm `RepositoryUrl` for matched releases. | | Output | `VersionInfo` now includes a `Date` field — `FirstDeployed` for the installed version, `Created` for the latest version. | | Discovery | New `pkg/helm/helm_repo_exporter.go` calls ArtifactHub's `/helm-exporter` API and (with `FindHelmRepoMatch` in `pkg/helm/findscore.go`) attaches the source repo URL to each release. Optional file cache via `ARTIFACT_HELM_REPO_HUB_CACHE_FILE`. | +| Discovery | `nova find --release-source labels` reads installed releases from the `helm.sh/chart` (or older `chart`) label and `meta.helm.sh/release-*` annotations on workloads, cronjobs, services and configmaps, so it needs no access to Secrets. It cannot see CRD-only charts or the parent of an umbrella chart (those releases are skipped), and it only matches Artifact Hub packages that published the installed version. The default, `--release-source secrets`, is unchanged. | | CLI | Removed the upstream "Want more? Automate Nova for free with Fairwinds Insights!" message that was printed after every command. | | Build | Multi-stage `Dockerfile` that builds `nova` from source instead of copying a pre-built binary. | | CI | GitHub Actions workflows that build a multi-arch image and push to Nudgebee's container registry. | @@ -65,6 +66,10 @@ nova find --containers # Output JSON nova find --format json + +# Read releases from object labels instead of Helm's release Secrets +# (for service accounts that may not list Secrets) +nova find --release-source labels ``` Run `nova --help` for the full command surface. diff --git a/cmd/root.go b/cmd/root.go index 543fc02..18e8a1d 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -156,6 +156,12 @@ func init() { klog.Exitf("Failed to bind chart-ignore-list flag: %v", err) } + findCmd.Flags().String("release-source", nova_helm.ReleaseSourceSecrets, "Where to read installed Helm releases from: secrets (Helm's release Secrets; needs list on secrets) or labels (helm.sh/chart labels on workloads, services and configmaps; no Secrets access, but misses CRD-only and umbrella charts)") + err = viper.BindPFlag("release-source", findCmd.Flags().Lookup("release-source")) + if err != nil { + klog.Exitf("Failed to bind release-source flag: %v", err) + } + klog.InitFlags(nil) _ = flag.Set("alsologtostderr", "true") _ = flag.Set("logtostderr", "true") @@ -361,6 +367,10 @@ func handleContainers(kubeContext, kubeConfigPath string) (*output.ContainersOut func handleHelm(kubeContext, kubeConfigPath string) (*output.Output, error) { h := nova_helm.NewHelm(kubeContext, kubeConfigPath) + h.ReleaseSource = viper.GetString("release-source") + if h.ReleaseSource != nova_helm.ReleaseSourceSecrets && h.ReleaseSource != nova_helm.ReleaseSourceLabels { + return nil, fmt.Errorf("--release-source must be %q or %q, got %q", nova_helm.ReleaseSourceSecrets, nova_helm.ReleaseSourceLabels, h.ReleaseSource) + } if viper.IsSet("desired-versions") { klog.V(3).Infof("desired-versions is set - attempting to load them") klog.V(8).Infof("raw desired-versions: %v", viper.Get("desired-versions")) diff --git a/pkg/helm/cluster.go b/pkg/helm/cluster.go index 5a657d3..e715abe 100644 --- a/pkg/helm/cluster.go +++ b/pkg/helm/cluster.go @@ -15,6 +15,7 @@ package helm import ( + "context" "fmt" "slices" @@ -31,6 +32,8 @@ import ( type Helm struct { Kube *kube.Connection DesiredVersions []DesiredVersion + // ReleaseSource is ReleaseSourceSecrets (default) or ReleaseSourceLabels. + ReleaseSource string } // DesiredVersion is a specific desired version that overrides the latest from the repository @@ -64,6 +67,13 @@ func (h *Helm) GetReleaseOutput(namespace string, releaseIgnoreList []string, ch // GetHelmReleases returns a list of helm releases from the cluster func (h *Helm) GetHelmReleases(namespace string, releaseIgnoreList []string, chartIgnoreList []string) ([]*release.Release, error) { + if h.ReleaseSource == ReleaseSourceLabels { + found, err := GetHelmReleasesFromLabels(context.Background(), h.Kube.Client, namespace) + if err != nil { + return nil, err + } + return filterIgnoredReleases(found, releaseIgnoreList, chartIgnoreList), nil + } hs := helmdriver.NewSecrets(h.Kube.Client.CoreV1().Secrets(namespace)) helmClient := helmstorage.Init(hs) deployed, err := helmClient.ListDeployed() diff --git a/pkg/helm/findscore.go b/pkg/helm/findscore.go index 0103566..691004e 100644 --- a/pkg/helm/findscore.go +++ b/pkg/helm/findscore.go @@ -37,10 +37,18 @@ func FindBestArtifactHubMatch(clusterRelease *release.Release, ahubPackages []Ar packageScores := map[packageKey]float32{} packageStars := map[packageKey]int{} var useStars bool + fromLabels := clusterRelease.Labels[releaseSourceKey] == ReleaseSourceLabels for _, p := range ahubPackages { if p.Name != clusterRelease.Chart.Metadata.Name { continue } + // A release read from labels has no chart metadata (home, sources, + // maintainers) to score on, so a same-name chart from an unrelated + // repo would often win. Only consider packages that have published + // the installed version; if none has, report no match rather than guess. + if fromLabels && !packagePublishedVersion(clusterRelease.Chart.Metadata.Version, p) { + continue + } key := packageKey{Name: p.Name, Repository: p.Repository.Name} packageScores[key] = scoreChartSimilarity(clusterRelease, p) @@ -196,6 +204,19 @@ func clusterVersionExistsInPackage(clusterVersion string, pkg ArtifactHubHelmPac return false } +// packagePublishedVersion reports whether pkg lists v among its versions, +// ignoring a leading "v" on either side (cert-manager labels "v1.13.1", +// Artifact Hub lists "1.13.1"). +func packagePublishedVersion(v string, pkg ArtifactHubHelmPackage) bool { + want := strings.TrimPrefix(v, "v") + for _, packageVersion := range pkg.AvailableVersions { + if strings.TrimPrefix(packageVersion.Version, "v") == want { + return true + } + } + return false +} + func containsString(arr []string, val string) bool { return slices.Contains(arr, val) } diff --git a/pkg/helm/labels.go b/pkg/helm/labels.go new file mode 100644 index 0000000..ba32b86 --- /dev/null +++ b/pkg/helm/labels.go @@ -0,0 +1,298 @@ +// Copyright 2026 Nudgebee, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package helm + +import ( + "context" + "errors" + "fmt" + "sort" + "strings" + + "github.com/Masterminds/semver/v3" + "helm.sh/helm/v3/pkg/chart" + "helm.sh/helm/v3/pkg/release" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes" + "k8s.io/klog/v2" +) + +const ( + // ReleaseSourceSecrets reads releases from Helm's release Secrets (needs + // cluster-wide list on secrets). + ReleaseSourceSecrets = "secrets" + // ReleaseSourceLabels derives releases from the labels and annotations Helm + // puts on the objects it installs. Needs no Secrets access. + ReleaseSourceLabels = "labels" + + chartLabel = "helm.sh/chart" + legacyChartLabel = "chart" // older charts (e.g. some prometheus-community ones) set only this + appVersionLabel = "app.kubernetes.io/version" + releaseNameAnnotation = "meta.helm.sh/release-name" + releaseNamespaceAnnotation = "meta.helm.sh/release-namespace" + + labelListPageSize = 500 + + // releaseSourceKey marks, in release.Labels, where nova found a release, + // so Artifact Hub matching can account for the missing chart metadata. + releaseSourceKey = "nova.release-source" +) + +// labelledObject is the metadata of one object that carries a helm.sh/chart label. +type labelledObject struct { + Namespace string + Labels map[string]string + Annotations map[string]string +} + +// objectLister lists the metadata of one kind of object, one page at a time. +type objectLister struct { + kind string + list func(ctx context.Context, namespace string, opts metav1.ListOptions) ([]metav1.ObjectMeta, string, error) +} + +func labelListers(client kubernetes.Interface) []objectLister { + return []objectLister{ + {"deployments", func(ctx context.Context, ns string, o metav1.ListOptions) ([]metav1.ObjectMeta, string, error) { + l, err := client.AppsV1().Deployments(ns).List(ctx, o) + if err != nil { + return nil, "", err + } + out := make([]metav1.ObjectMeta, len(l.Items)) + for i := range l.Items { + out[i] = l.Items[i].ObjectMeta + } + return out, l.Continue, nil + }}, + {"statefulsets", func(ctx context.Context, ns string, o metav1.ListOptions) ([]metav1.ObjectMeta, string, error) { + l, err := client.AppsV1().StatefulSets(ns).List(ctx, o) + if err != nil { + return nil, "", err + } + out := make([]metav1.ObjectMeta, len(l.Items)) + for i := range l.Items { + out[i] = l.Items[i].ObjectMeta + } + return out, l.Continue, nil + }}, + {"daemonsets", func(ctx context.Context, ns string, o metav1.ListOptions) ([]metav1.ObjectMeta, string, error) { + l, err := client.AppsV1().DaemonSets(ns).List(ctx, o) + if err != nil { + return nil, "", err + } + out := make([]metav1.ObjectMeta, len(l.Items)) + for i := range l.Items { + out[i] = l.Items[i].ObjectMeta + } + return out, l.Continue, nil + }}, + {"cronjobs", func(ctx context.Context, ns string, o metav1.ListOptions) ([]metav1.ObjectMeta, string, error) { + l, err := client.BatchV1().CronJobs(ns).List(ctx, o) + if err != nil { + return nil, "", err + } + out := make([]metav1.ObjectMeta, len(l.Items)) + for i := range l.Items { + out[i] = l.Items[i].ObjectMeta + } + return out, l.Continue, nil + }}, + {"services", func(ctx context.Context, ns string, o metav1.ListOptions) ([]metav1.ObjectMeta, string, error) { + l, err := client.CoreV1().Services(ns).List(ctx, o) + if err != nil { + return nil, "", err + } + out := make([]metav1.ObjectMeta, len(l.Items)) + for i := range l.Items { + out[i] = l.Items[i].ObjectMeta + } + return out, l.Continue, nil + }}, + {"configmaps", func(ctx context.Context, ns string, o metav1.ListOptions) ([]metav1.ObjectMeta, string, error) { + l, err := client.CoreV1().ConfigMaps(ns).List(ctx, o) + if err != nil { + return nil, "", err + } + out := make([]metav1.ObjectMeta, len(l.Items)) + for i := range l.Items { + out[i] = l.Items[i].ObjectMeta + } + return out, l.Continue, nil + }}, + } +} + +// GetHelmReleasesFromLabels derives the installed Helm releases from the +// helm.sh/chart label (or the older "chart" label) and the +// meta.helm.sh/release-* annotations on workloads, +// cronjobs, services and configmaps. It needs list on those kinds only, never +// on Secrets. +// +// What it cannot see compared to the Secrets source: releases that install +// none of those kinds (e.g. CRD-only charts), and chart metadata (home, +// sources, maintainers) used to score Artifact Hub matches. A release whose +// objects carry more than one chart label (an umbrella chart, where each +// subchart labels its own objects) is skipped: the parent chart is not +// recoverable from labels, and reporting a subchart would recommend the +// wrong upgrade. +func GetHelmReleasesFromLabels(ctx context.Context, client kubernetes.Interface, namespace string) ([]*release.Release, error) { + var objects []labelledObject + var errs []error + listers := labelListers(client) + selectors := []string{chartLabel, legacyChartLabel + ",!" + chartLabel} + for _, l := range listers { + for _, selector := range selectors { + opts := metav1.ListOptions{LabelSelector: selector, Limit: labelListPageSize} + for { + items, cont, err := l.list(ctx, namespace, opts) + if err != nil { + klog.V(2).Infof("listing %s (%s) for helm labels: %v", l.kind, selector, err) + errs = append(errs, fmt.Errorf("%s: %w", l.kind, err)) + break + } + for _, m := range items { + objects = append(objects, labelledObject{Namespace: m.Namespace, Labels: m.Labels, Annotations: m.Annotations}) + } + if cont == "" { + break + } + opts.Continue = cont + } + } + } + if len(errs) == len(listers)*len(selectors) { + return nil, fmt.Errorf("could not list any labelled objects: %w", errors.Join(errs...)) + } + return releasesFromObjects(objects), nil +} + +type releaseKey struct { + namespace string + name string +} + +type releaseLabels struct { + charts map[string]bool + appVersions map[string]bool +} + +// releasesFromObjects groups labelled objects by release and returns one +// release per group that names exactly one parseable chart. +func releasesFromObjects(objects []labelledObject) []*release.Release { + groups := map[releaseKey]*releaseLabels{} + for _, o := range objects { + name := o.Annotations[releaseNameAnnotation] + chartValue := o.Labels[chartLabel] + if chartValue == "" { + chartValue = o.Labels[legacyChartLabel] + } + if name == "" || chartValue == "" { + continue + } + ns := o.Annotations[releaseNamespaceAnnotation] + if ns == "" { + ns = o.Namespace + } + k := releaseKey{namespace: ns, name: name} + g := groups[k] + if g == nil { + g = &releaseLabels{charts: map[string]bool{}, appVersions: map[string]bool{}} + groups[k] = g + } + g.charts[chartValue] = true + if v := o.Labels[appVersionLabel]; v != "" { + g.appVersions[v] = true + } + } + + keys := make([]releaseKey, 0, len(groups)) + for k := range groups { + keys = append(keys, k) + } + sort.Slice(keys, func(i, j int) bool { + if keys[i].namespace != keys[j].namespace { + return keys[i].namespace < keys[j].namespace + } + return keys[i].name < keys[j].name + }) + + var out []*release.Release + for _, k := range keys { + g := groups[k] + if len(g.charts) != 1 { + klog.V(2).Infof("skipping release %s/%s: objects carry %d different chart labels", k.namespace, k.name, len(g.charts)) + continue + } + var chartValue string + for c := range g.charts { + chartValue = c + } + chartName, chartVersion, ok := splitChartLabel(chartValue) + if !ok { + klog.V(2).Infof("skipping release %s/%s: cannot split chart label %q into name and version", k.namespace, k.name, chartValue) + continue + } + var appVersion string + if len(g.appVersions) == 1 { + for v := range g.appVersions { + appVersion = v + } + } + out = append(out, &release.Release{ + Name: k.name, + Namespace: k.namespace, + Chart: &chart.Chart{Metadata: &chart.Metadata{ + Name: chartName, + Version: chartVersion, + AppVersion: appVersion, + }}, + Info: &release.Info{Status: release.StatusDeployed}, + Labels: map[string]string{releaseSourceKey: ReleaseSourceLabels}, + }) + } + return out +} + +// splitChartLabel splits a helm.sh/chart label value ("-", +// with "+" written as "_") into chart name and version. Both parts may +// contain "-", so it takes the leftmost "-" after which the rest is a strict +// semantic version (x.y.z). Failing that, it accepts a shorter "x.y" version +// (Helm tolerates those), still requiring a dot so a numeric name part such as +// "foo-2-bar" is not mistaken for a version. +func splitChartLabel(value string) (string, string, bool) { + for _, strict := range []bool{true, false} { + for i := 1; i < len(value); i++ { + if value[i] != '-' { + continue + } + candidate := strings.ReplaceAll(value[i+1:], "_", "+") + bare := strings.TrimPrefix(candidate, "v") + if strict { + if _, err := semver.StrictNewVersion(bare); err == nil { + return value[:i], candidate, true + } + continue + } + core, _, _ := strings.Cut(strings.SplitN(bare, "+", 2)[0], "-") + if !strings.Contains(core, ".") { + continue + } + if _, err := semver.NewVersion(bare); err == nil { + return value[:i], candidate, true + } + } + } + return "", "", false +} diff --git a/pkg/helm/labels_test.go b/pkg/helm/labels_test.go new file mode 100644 index 0000000..7127e20 --- /dev/null +++ b/pkg/helm/labels_test.go @@ -0,0 +1,178 @@ +// Copyright 2026 Nudgebee, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package helm + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/client-go/kubernetes/fake" + k8stesting "k8s.io/client-go/testing" +) + +func TestSplitChartLabel(t *testing.T) { + tests := []struct { + in, name, version string + ok bool + }{ + {"cert-manager-v1.13.1", "cert-manager", "v1.13.1", true}, + {"my-agent-0.1.33-rc-4", "my-agent", "0.1.33-rc-4", true}, + {"redis-17.11.8", "redis", "17.11.8", true}, + {"app-0.1", "app", "0.1", true}, + {"foo-2-bar-1.0.0", "foo-2-bar", "1.0.0", true}, + {"foo-2-bar-0.3", "foo-2-bar", "0.3", true}, + {"chart-1.2.3_build.5", "chart", "1.2.3+build.5", true}, + {"no-version", "", "", false}, + {"chart-2", "", "", false}, + {"", "", "", false}, + } + for _, tt := range tests { + t.Run(tt.in, func(t *testing.T) { + name, version, ok := splitChartLabel(tt.in) + assert.Equal(t, tt.ok, ok) + assert.Equal(t, tt.name, name) + assert.Equal(t, tt.version, version) + }) + } +} + +func obj(ns, release, chartLabelValue string) labelledObject { + return labelledObject{ + Namespace: ns, + Labels: map[string]string{chartLabel: chartLabelValue}, + Annotations: map[string]string{releaseNameAnnotation: release, releaseNamespaceAnnotation: ns}, + } +} + +func TestReleasesFromObjects(t *testing.T) { + objects := []labelledObject{ + obj("web", "ingress", "ingress-nginx-4.10.1"), + obj("web", "ingress", "ingress-nginx-4.10.1"), // deployment + service of one release + // umbrella chart: each subchart labels its own objects + obj("mon", "stack", "kube-state-metrics-5.28.1"), + obj("mon", "stack", "prometheus-node-exporter-4.43.1"), + // same release name in another namespace is a different release + obj("web2", "ingress", "ingress-nginx-4.9.0"), + // no release annotation (not installed by Helm 3) is ignored + {Namespace: "x", Labels: map[string]string{chartLabel: "thing-1.0.0"}}, + // unparseable chart label is skipped + obj("y", "odd", "odd"), + } + objects[0].Labels[appVersionLabel] = "1.10.1" + + got := releasesFromObjects(objects) + require.Len(t, got, 2) + + assert.Equal(t, "ingress", got[0].Name) + assert.Equal(t, "web", got[0].Namespace) + assert.Equal(t, "ingress-nginx", got[0].Chart.Metadata.Name) + assert.Equal(t, "4.10.1", got[0].Chart.Metadata.Version) + assert.Equal(t, "1.10.1", got[0].Chart.Metadata.AppVersion) + require.NotNil(t, got[0].Info) + assert.Equal(t, ReleaseSourceLabels, got[0].Labels[releaseSourceKey]) + + assert.Equal(t, "web2", got[1].Namespace) + assert.Equal(t, "4.9.0", got[1].Chart.Metadata.Version) +} + +func TestReleasesFromObjects_ReleaseNamespaceFallsBackToObjectNamespace(t *testing.T) { + o := labelledObject{ + Namespace: "apps", + Labels: map[string]string{chartLabel: "web-1.0.0"}, + Annotations: map[string]string{releaseNameAnnotation: "web"}, + } + got := releasesFromObjects([]labelledObject{o}) + require.Len(t, got, 1) + assert.Equal(t, "apps", got[0].Namespace) +} + +func helmMeta(name, ns, release, chartLabelValue string) metav1.ObjectMeta { + return metav1.ObjectMeta{ + Name: name, + Namespace: ns, + Labels: map[string]string{chartLabel: chartLabelValue}, + Annotations: map[string]string{releaseNameAnnotation: release, releaseNamespaceAnnotation: ns}, + } +} + +func TestGetHelmReleasesFromLabels_ForbiddenKindIsSkipped(t *testing.T) { + client := fake.NewClientset( + &appsv1.Deployment{ObjectMeta: helmMeta("api", "app", "api", "api-2.0.0")}, + &corev1.Service{ObjectMeta: helmMeta("db", "data", "db", "postgresql-12.1.0")}, + &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: "plain", Namespace: "data"}}, + ) + client.PrependReactor("list", "configmaps", func(k8stesting.Action) (bool, runtime.Object, error) { + return true, nil, apierrors.NewForbidden(schema.GroupResource{Resource: "configmaps"}, "", nil) + }) + + legacy := helmMeta("exporter", "mon", "exporter", "") + legacy.Labels = map[string]string{legacyChartLabel: "prometheus-postgres-exporter-6.8.1"} + require.NoError(t, client.Tracker().Add(&appsv1.Deployment{ObjectMeta: legacy})) + + got, err := GetHelmReleasesFromLabels(context.Background(), client, "") + require.NoError(t, err) + require.Len(t, got, 3) + assert.Equal(t, "api", got[0].Chart.Metadata.Name) + assert.Equal(t, "postgresql", got[1].Chart.Metadata.Name) + assert.Equal(t, "prometheus-postgres-exporter", got[2].Chart.Metadata.Name) + assert.Equal(t, "6.8.1", got[2].Chart.Metadata.Version) +} + +func TestGetHelmReleasesFromLabels_AllKindsForbidden(t *testing.T) { + client := fake.NewClientset() + client.PrependReactor("list", "*", func(k8stesting.Action) (bool, runtime.Object, error) { + return true, nil, apierrors.NewForbidden(schema.GroupResource{}, "", nil) + }) + _, err := GetHelmReleasesFromLabels(context.Background(), client, "") + assert.Error(t, err) +} + +func TestFindBestArtifactHubMatch_LabelsRequireInstalledVersion(t *testing.T) { + rel := releasesFromObjects([]labelledObject{obj("mon", "grafana", "grafana-11.1.1")})[0] + popular := ArtifactHubHelmPackage{ + Name: "grafana", Version: "10.5.15", Stars: 500, Official: true, + Repository: ArtifactHubRepository{Name: "popular", VerifiedPublisher: true}, + AvailableVersions: []AvailableVersion{{Version: "10.5.15"}}, + } + upstream := ArtifactHubHelmPackage{ + Name: "grafana", Version: "12.1.8", Stars: 1, + Repository: ArtifactHubRepository{Name: "upstream"}, + AvailableVersions: []AvailableVersion{{Version: "11.1.1"}, {Version: "12.1.8"}}, + } + + o := FindBestArtifactHubMatch(rel, []ArtifactHubHelmPackage{popular, upstream}) + require.NotNil(t, o) + assert.Equal(t, "12.1.8", o.Latest.Version) + + o = FindBestArtifactHubMatch(rel, []ArtifactHubHelmPackage{popular}) + require.NotNil(t, o) + assert.Empty(t, o.Latest.Version, "no package published 11.1.1, so no recommendation") + assert.False(t, o.IsOld) +} + +func TestPackagePublishedVersion_IgnoresVPrefix(t *testing.T) { + pkg := ArtifactHubHelmPackage{AvailableVersions: []AvailableVersion{{Version: "1.13.1"}}} + assert.True(t, packagePublishedVersion("v1.13.1", pkg)) + assert.True(t, packagePublishedVersion("1.13.1", pkg)) + assert.False(t, packagePublishedVersion("1.13.2", pkg)) +}