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)) +}