@skyhook-io/k8s-ui 1.7.6 → 1.7.8

package/src/utils/git-provider-urls.test.ts

@@ -0,0 +1,348 @@
+import { describe, it, expect } from 'vitest'
+import { buildRepoBrowseUrl, buildPathBrowseUrl } from './git-provider-urls'
+
+describe('buildRepoBrowseUrl', () => {
+  // Pass-through semantics: link the user's URL exactly as configured, no rewriting.
+  it('returns the input verbatim for https URL', () => {
+    expect(buildRepoBrowseUrl('https://github.com/KoalaOps/deployment')).toBe(
+      'https://github.com/KoalaOps/deployment'
+    )
+  })
+
+  it('preserves trailing .git suffix (no manipulation)', () => {
+    expect(buildRepoBrowseUrl('https://github.com/KoalaOps/deployment.git')).toBe(
+      'https://github.com/KoalaOps/deployment.git'
+    )
+  })
+
+  it('preserves trailing slash (no manipulation)', () => {
+    expect(buildRepoBrowseUrl('https://github.com/KoalaOps/deployment/')).toBe(
+      'https://github.com/KoalaOps/deployment/'
+    )
+  })
+
+  it('trims surrounding whitespace', () => {
+    expect(buildRepoBrowseUrl('  https://github.com/o/r  ')).toBe(
+      'https://github.com/o/r'
+    )
+  })
+
+  it('keeps unknown hosts (still a valid http(s) link)', () => {
+    expect(buildRepoBrowseUrl('https://git.internal.example.com/team/proj')).toBe(
+      'https://git.internal.example.com/team/proj'
+    )
+  })
+
+  it('preserves non-default port in self-hosted URLs', () => {
+    expect(buildRepoBrowseUrl('https://gitea.internal:3000/team/repo')).toBe(
+      'https://gitea.internal:3000/team/repo'
+    )
+  })
+
+  it('preserves http:// scheme (does not silently upgrade to https)', () => {
+    expect(buildRepoBrowseUrl('http://corp.example.com/team/repo')).toBe(
+      'http://corp.example.com/team/repo'
+    )
+  })
+
+  it('returns null for SCP-form (git@host:owner/repo) — not http(s)', () => {
+    expect(buildRepoBrowseUrl('git@github.com:KoalaOps/deployment.git')).toBe(null)
+  })
+
+  it('returns null for ssh:// scheme', () => {
+    expect(buildRepoBrowseUrl('ssh://git@github.com/KoalaOps/deployment.git')).toBe(null)
+  })
+
+  it('returns null for git+ssh:// scheme', () => {
+    expect(buildRepoBrowseUrl('git+ssh://git@github.com/o/r.git')).toBe(null)
+  })
+
+  it('returns null for oci:// scheme (Helm OCI registry)', () => {
+    expect(buildRepoBrowseUrl('oci://registry.example.com/charts/nginx')).toBe(null)
+  })
+
+  it('returns null for file:// scheme', () => {
+    expect(buildRepoBrowseUrl('file:///tmp/repo')).toBe(null)
+  })
+
+  it('returns null for javascript: scheme (XSS-safe)', () => {
+    expect(buildRepoBrowseUrl('javascript:alert(1)')).toBe(null)
+  })
+
+  it('returns null for empty / nullish input', () => {
+    expect(buildRepoBrowseUrl('')).toBe(null)
+    expect(buildRepoBrowseUrl(undefined)).toBe(null)
+    expect(buildRepoBrowseUrl(null)).toBe(null)
+    expect(buildRepoBrowseUrl('   ')).toBe(null)
+  })
+
+  it('returns null for non-URL garbage', () => {
+    expect(buildRepoBrowseUrl('not a url')).toBe(null)
+  })
+})
+
+describe('buildPathBrowseUrl - GitHub', () => {
+  it('builds tree URL with branch ref', () => {
+    expect(
+      buildPathBrowseUrl(
+        'https://github.com/KoalaOps/deployment',
+        'argocd/addons/keda/keda/nonprod-cluster-us-east1',
+        'main'
+      )
+    ).toBe(
+      'https://github.com/KoalaOps/deployment/tree/main/argocd/addons/keda/keda/nonprod-cluster-us-east1'
+    )
+  })
+
+  it('uses HEAD when targetRevision is empty', () => {
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'src', '')
+    ).toBe('https://github.com/o/r/tree/HEAD/src')
+  })
+
+  it('uses HEAD when targetRevision is literally "HEAD"', () => {
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'src', 'HEAD')
+    ).toBe('https://github.com/o/r/tree/HEAD/src')
+  })
+
+  it('passes SHA through as the ref (no special prefix)', () => {
+    const sha = 'a'.repeat(40)
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'src', sha)
+    ).toBe(`https://github.com/o/r/tree/${sha}/src`)
+  })
+
+  it('works with .git suffix on repo URL', () => {
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r.git', 'a/b', 'main')
+    ).toBe('https://github.com/o/r/tree/main/a/b')
+  })
+
+  it('url-encodes path segments with spaces', () => {
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'dir with space/file', 'main')
+    ).toBe('https://github.com/o/r/tree/main/dir%20with%20space/file')
+  })
+
+  it('drops empty path segments from double slashes', () => {
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'a//b', 'main')
+    ).toBe('https://github.com/o/r/tree/main/a/b')
+  })
+
+  it('preserves slashes in branch names (feature/foo)', () => {
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'src', 'feature/foo')
+    ).toBe('https://github.com/o/r/tree/feature/foo/src')
+  })
+
+  it('treats uppercase 40-hex as a SHA (no special prefix)', () => {
+    const sha = 'A'.repeat(40)
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'src', sha)
+    ).toBe(`https://github.com/o/r/tree/${sha}/src`)
+  })
+})
+
+describe('buildPathBrowseUrl - GitLab', () => {
+  it('builds /-/tree URL', () => {
+    expect(
+      buildPathBrowseUrl('https://gitlab.com/group/proj', 'src/app', 'main')
+    ).toBe('https://gitlab.com/group/proj/-/tree/main/src/app')
+  })
+
+  it('supports nested subgroups (full group path before /-/tree)', () => {
+    expect(
+      buildPathBrowseUrl('https://gitlab.com/group/sub/proj', 'src', 'main')
+    ).toBe('https://gitlab.com/group/sub/proj/-/tree/main/src')
+  })
+})
+
+describe('buildPathBrowseUrl - Bitbucket', () => {
+  it('builds /src URL with explicit ref', () => {
+    expect(
+      buildPathBrowseUrl('https://bitbucket.org/team/proj', 'src/app', 'develop')
+    ).toBe('https://bitbucket.org/team/proj/src/develop/src/app')
+  })
+
+  // Bitbucket Cloud /src/ doesn't accept "HEAD" — better no link than a 404 link.
+  it('returns null when ref is empty (HEAD not a valid Bitbucket ref token)', () => {
+    expect(
+      buildPathBrowseUrl('https://bitbucket.org/team/proj', 'src/app', '')
+    ).toBe(null)
+  })
+  it('returns null when ref is literally "HEAD"', () => {
+    expect(
+      buildPathBrowseUrl('https://bitbucket.org/team/proj', 'src/app', 'HEAD')
+    ).toBe(null)
+  })
+})
+
+describe('buildPathBrowseUrl - Azure DevOps', () => {
+  it('builds dev.azure.com URL with GB prefix for branches', () => {
+    expect(
+      buildPathBrowseUrl(
+        'https://dev.azure.com/myorg/MyProject/_git/myrepo',
+        'src/app',
+        'main'
+      )
+    ).toBe(
+      'https://dev.azure.com/myorg/MyProject/_git/myrepo?path=/src/app&version=GBmain'
+    )
+  })
+
+  it('uses GC prefix for SHA refs (lowercase)', () => {
+    const sha = 'a'.repeat(40)
+    expect(
+      buildPathBrowseUrl(
+        'https://dev.azure.com/myorg/MyProject/_git/myrepo',
+        'src',
+        sha
+      )
+    ).toBe(
+      `https://dev.azure.com/myorg/MyProject/_git/myrepo?path=/src&version=GC${sha}`
+    )
+  })
+
+  it('uses GC prefix for SHA refs (uppercase)', () => {
+    const sha = 'A'.repeat(40)
+    expect(
+      buildPathBrowseUrl(
+        'https://dev.azure.com/myorg/MyProject/_git/myrepo',
+        'src',
+        sha
+      )
+    ).toBe(
+      `https://dev.azure.com/myorg/MyProject/_git/myrepo?path=/src&version=GC${sha}`
+    )
+  })
+
+  it('percent-encodes slashes in branch names (query-string context)', () => {
+    expect(
+      buildPathBrowseUrl(
+        'https://dev.azure.com/myorg/MyProject/_git/myrepo',
+        'src',
+        'feature/foo'
+      )
+    ).toBe(
+      'https://dev.azure.com/myorg/MyProject/_git/myrepo?path=/src&version=GBfeature%2Ffoo'
+    )
+  })
+
+  it('omits version when ref is HEAD/empty', () => {
+    expect(
+      buildPathBrowseUrl(
+        'https://dev.azure.com/myorg/MyProject/_git/myrepo',
+        'src',
+        'HEAD'
+      )
+    ).toBe('https://dev.azure.com/myorg/MyProject/_git/myrepo?path=/src')
+  })
+
+  it('supports legacy visualstudio.com host', () => {
+    expect(
+      buildPathBrowseUrl(
+        'https://myorg.visualstudio.com/MyProject/_git/myrepo',
+        'src',
+        'main'
+      )
+    ).toBe(
+      'https://dev.azure.com/myorg/MyProject/_git/myrepo?path=/src&version=GBmain'
+    )
+  })
+
+  it('does not double-encode project/repo segments that arrived percent-encoded', () => {
+    expect(
+      buildPathBrowseUrl(
+        'https://dev.azure.com/myorg/My%20Project/_git/My%20Repo',
+        'src',
+        'main'
+      )
+    ).toBe(
+      'https://dev.azure.com/myorg/My%20Project/_git/My%20Repo?path=/src&version=GBmain'
+    )
+  })
+})
+
+describe('buildPathBrowseUrl - unknown / no path', () => {
+  it('returns null for unknown hosts', () => {
+    expect(
+      buildPathBrowseUrl('https://git.internal.example.com/team/proj', 'src', 'main')
+    ).toBe(null)
+  })
+
+  it('returns null when path is empty', () => {
+    expect(buildPathBrowseUrl('https://github.com/o/r', '', 'main')).toBe(null)
+    expect(buildPathBrowseUrl('https://github.com/o/r', '   ', 'main')).toBe(null)
+    expect(buildPathBrowseUrl('https://github.com/o/r', null, 'main')).toBe(null)
+  })
+
+  it('returns null when path has only slashes', () => {
+    expect(buildPathBrowseUrl('https://github.com/o/r', '///', 'main')).toBe(null)
+  })
+
+  it('returns null for nullish repo URL', () => {
+    expect(buildPathBrowseUrl(undefined, 'src', 'main')).toBe(null)
+  })
+
+  // Known host but path too short to identify owner+repo -> downgrade to unknown.
+  // Pins the `pathParts.length < 2` guard across all three slash-providers.
+  it('returns null when github URL has only owner segment', () => {
+    expect(buildPathBrowseUrl('https://github.com/onlyowner', 'src', 'main')).toBe(null)
+  })
+  it('returns null when bitbucket URL has only owner segment', () => {
+    expect(buildPathBrowseUrl('https://bitbucket.org/onlyowner', 'src', 'main')).toBe(null)
+  })
+  it('returns null when gitlab URL has only one segment', () => {
+    expect(buildPathBrowseUrl('https://gitlab.com/onlyone', 'src', 'main')).toBe(null)
+  })
+
+  // Azure DevOps `_git` index arithmetic — high-risk branch.
+  it('returns null when dev.azure.com URL is missing _git', () => {
+    expect(
+      buildPathBrowseUrl('https://dev.azure.com/myorg/MyProject/myrepo', 'src', 'main')
+    ).toBe(null)
+  })
+  it('returns null when dev.azure.com URL ends with _git (no repo segment)', () => {
+    expect(
+      buildPathBrowseUrl('https://dev.azure.com/myorg/MyProject/_git', 'src', 'main')
+    ).toBe(null)
+  })
+  it('returns null when dev.azure.com URL has _git but no project (gitIdx < 2)', () => {
+    expect(
+      buildPathBrowseUrl('https://dev.azure.com/myorg/_git/myrepo', 'src', 'main')
+    ).toBe(null)
+  })
+  it('returns null when visualstudio.com URL is missing _git', () => {
+    expect(
+      buildPathBrowseUrl('https://myorg.visualstudio.com/MyProject/myrepo', 'src', 'main')
+    ).toBe(null)
+  })
+  it('returns null when visualstudio.com URL ends with _git', () => {
+    expect(
+      buildPathBrowseUrl('https://myorg.visualstudio.com/MyProject/_git', 'src', 'main')
+    ).toBe(null)
+  })
+
+  // Pin .toUpperCase() behavior so a refactor to === 'HEAD' would fail loudly.
+  it('treats lowercase "head" the same as "HEAD" (falls back to default branch)', () => {
+    expect(
+      buildPathBrowseUrl('https://github.com/o/r', 'src', 'head')
+    ).toBe('https://github.com/o/r/tree/HEAD/src')
+  })
+
+  // Pin SHA_RE's exact-40-char requirement. Loosening to {7,40} would mis-prefix
+  // short-hex branch names like "abc1234" as Azure commits (GC) instead of branches (GB).
+  it('does not treat 7-char hex as a SHA on Azure (stays GB)', () => {
+    expect(
+      buildPathBrowseUrl(
+        'https://dev.azure.com/myorg/MyProject/_git/myrepo',
+        'src',
+        'abc1234'
+      )
+    ).toBe(
+      'https://dev.azure.com/myorg/MyProject/_git/myrepo?path=/src&version=GBabc1234'
+    )
+  })
+})

package/src/utils/git-provider-urls.ts

@@ -0,0 +1,142 @@
+type ParsedRepo =
+  | { provider: 'github' | 'gitlab' | 'bitbucket'; owner: string; repo: string }
+  | { provider: 'azure-devops'; org: string; project: string; repo: string }
+  | { provider: 'unknown' }
+
+const SHA_RE = /^[0-9a-f]{40}$/i
+
+function stripDotGit(s: string): string {
+  return s.replace(/\.git$/i, '')
+}
+
+function encodePath(path: string): string {
+  return path
+    .split('/')
+    .filter(seg => seg.length > 0)
+    .map(encodeURIComponent)
+    .join('/')
+}
+
+// Refs (branches) can contain slashes — feature/foo — which providers serve as
+// literal path segments. encodeURIComponent would turn those into %2F and 404.
+function encodeRef(ref: string): string {
+  return ref.split('/').map(encodeURIComponent).join('/')
+}
+
+// Validate `repoURL` is a well-formed http(s) URL and return the URL object.
+// SCP-form (git@host:o/r), ssh://, git+ssh://, oci://, file://, etc. all
+// return null — we don't manipulate user-supplied URLs to make them linkable.
+function parseHttpRepoUrl(repoURL: string | undefined | null): URL | null {
+  if (!repoURL) return null
+  const trimmed = repoURL.trim()
+  if (!trimmed) return null
+  let url: URL
+  try {
+    url = new URL(trimmed)
+  } catch {
+    return null
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') return null
+  return url
+}
+
+function detectProvider(url: URL): ParsedRepo {
+  const hostname = url.hostname.toLowerCase()
+  const pathParts = url.pathname.replace(/^\/+/, '').replace(/\/+$/, '').split('/')
+
+  if (hostname === 'github.com' || hostname === 'bitbucket.org') {
+    if (pathParts.length < 2) return { provider: 'unknown' }
+    return {
+      provider: hostname === 'github.com' ? 'github' : 'bitbucket',
+      owner: pathParts[0],
+      repo: stripDotGit(pathParts[1]),
+    }
+  }
+
+  if (hostname === 'gitlab.com') {
+    // GitLab supports nested groups: the owner segment may itself be a slash-joined path.
+    if (pathParts.length < 2) return { provider: 'unknown' }
+    return {
+      provider: 'gitlab',
+      owner: pathParts.slice(0, -1).join('/'),
+      repo: stripDotGit(pathParts[pathParts.length - 1]),
+    }
+  }
+
+  // Azure DevOps URL shape: /{org}/{project}/_git/{repo} (dev.azure.com)
+  // or {org}.visualstudio.com/{project}/_git/{repo} (legacy).
+  if (hostname === 'dev.azure.com') {
+    const gitIdx = pathParts.indexOf('_git')
+    if (gitIdx < 2 || gitIdx + 1 >= pathParts.length) {
+      return { provider: 'unknown' }
+    }
+    return {
+      provider: 'azure-devops',
+      org: pathParts.slice(0, gitIdx - 1).join('/'),
+      project: pathParts[gitIdx - 1],
+      repo: pathParts[gitIdx + 1],
+    }
+  }
+
+  if (hostname.endsWith('.visualstudio.com')) {
+    const gitIdx = pathParts.indexOf('_git')
+    if (gitIdx < 1 || gitIdx + 1 >= pathParts.length) {
+      return { provider: 'unknown' }
+    }
+    return {
+      provider: 'azure-devops',
+      org: hostname.slice(0, -'.visualstudio.com'.length),
+      project: pathParts.slice(0, gitIdx).join('/'),
+      repo: pathParts[gitIdx + 1],
+    }
+  }
+
+  return { provider: 'unknown' }
+}
+
+// Pass-through linkability check: link the user's repoURL as-is iff it parses
+// as http(s); never rewrite SCP/SSH forms.
+export function buildRepoBrowseUrl(repoURL: string | undefined | null): string | null {
+  return parseHttpRepoUrl(repoURL) ? repoURL!.trim() : null
+}
+
+export function buildPathBrowseUrl(
+  repoURL: string | undefined | null,
+  path: string | undefined | null,
+  targetRevision: string | undefined | null
+): string | null {
+  if (!path || !path.trim()) return null
+  const url = parseHttpRepoUrl(repoURL)
+  if (!url) return null
+  const parsed = detectProvider(url)
+  if (parsed.provider === 'unknown') return null
+
+  const rawRef = (targetRevision ?? '').trim()
+  // GitHub and GitLab browse URLs accept "HEAD" as a ref token that resolves
+  // to the default branch. Bitbucket Cloud's /src/ path does not — see the
+  // bitbucket case below.
+  const hasExplicitRef = rawRef !== '' && rawRef.toUpperCase() !== 'HEAD'
+  const ref = hasExplicitRef ? rawRef : 'HEAD'
+  const encodedPath = encodePath(path)
+  if (!encodedPath) return null
+
+  switch (parsed.provider) {
+    case 'github':
+      return `https://github.com/${parsed.owner}/${parsed.repo}/tree/${encodeRef(ref)}/${encodedPath}`
+    case 'gitlab':
+      return `https://gitlab.com/${parsed.owner}/${parsed.repo}/-/tree/${encodeRef(ref)}/${encodedPath}`
+    case 'bitbucket':
+      // Bitbucket Cloud's /src/{ref}/... endpoint requires a real branch name
+      // or commit hash; HEAD 404s. Without an explicit ref we can't build a
+      // working deep link, so fall through to plain text.
+      if (!hasExplicitRef) return null
+      return `https://bitbucket.org/${parsed.owner}/${parsed.repo}/src/${encodeRef(ref)}/${encodedPath}`
+    case 'azure-devops': {
+      const isSha = hasExplicitRef && SHA_RE.test(rawRef)
+      const versionParam = hasExplicitRef ? `&version=${isSha ? 'GC' : 'GB'}${encodeURIComponent(rawRef)}` : ''
+      // org/project/repo are taken straight from url.pathname segments, which the URL
+      // parser leaves percent-encoded — re-encoding would double-encode (My%20X → My%2520X).
+      return `https://dev.azure.com/${parsed.org}/${parsed.project}/_git/${parsed.repo}?path=/${encodedPath}${versionParam}`
+    }
+  }
+}

package/src/utils/index.ts

@@ -8,6 +8,7 @@ export * from './animation'
 export * from './resource-hierarchy'
 export * from './log-format'
 export * from './download'
+export * from './env-from'
 export * from './api-resources'
 export * from './skeleton-yaml'
 export * from './k8s-errors'
@@ -17,3 +18,4 @@ export * from './validators'
 export * from './gitops-owner'
 export * from './gitops-route'
 export * from './rbac-badges'
+export * from './git-provider-urls'

package/src/utils/replica-scalers.ts

@@ -0,0 +1,9 @@
+import type { ResourceRef } from '../types'
+
+export function replicaScalers(scalers?: ResourceRef[]): ResourceRef[] | undefined {
+  const result = scalers?.filter((ref) => {
+    const kind = ref.kind.toLowerCase()
+    return kind === 'horizontalpodautoscaler' || kind === 'scaledobject'
+  })
+  return result && result.length > 0 ? result : undefined
+}

package/src/components/resources/resources-search-sidebar-hint.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { pluralize } from '../../utils/pluralize'
-import type { SelectedKindInfo } from './ResourcesSidebar'
-
-// Mirrors the empty-state hint rule inside ResourcesView (kept in
-// sync by reuse) — pure so we can pin the lookup + render contract
-// without rendering the React component. See
-// `packages/k8s-ui/src/components/resources/ResourcesView.tsx`
-// search for "the count is unfiltered".
-function sidebarHint(
-  counts: Record<string, number>,
-  selectedKind: SelectedKindInfo,
-  searchTerm: string,
-): string | null {
-  if (!searchTerm) return null
-  const key = selectedKind.group ? `${selectedKind.group}/${selectedKind.kind}` : selectedKind.kind
-  const totalForKind = counts[key] ?? 0
-  if (totalForKind === 0) return null
-  return `The sidebar shows ${pluralize(totalForKind, selectedKind.kind)} in the cluster — the count is unfiltered.`
-}
-
-describe('ResourcesView empty-search sidebar hint (SKY-828 bug 46)', () => {
-  // The bug: sidebar count badge stays unfiltered and shows the
-  // cluster-wide total per kind. When a search returns zero rows
-  // (e.g. "5 Pods" in sidebar, "No Pods found" in pane) the user
-  // reads the badge as a lie. The empty-state appends a sentence
-  // making the unfiltered nature explicit. The rule must:
-  //   1. Suppress entirely when there's no active search.
-  //   2. Suppress when the cluster total for the kind is 0
-  //      (no badge to explain → no hint).
-  //   3. Look up the count under `${group}/${kind}` for grouped
-  //      kinds, plain `kind` for core kinds (matches sidebar key).
-  //   4. Pluralize via pluralize() so "Ingress" → "Ingresses",
-  //      "NetworkPolicy" → "NetworkPolicies" (regression of the
-  //      naive `${kind}s` Cursor Bugbot caught in 80eb64b).
-  //   5. Singular for n===1: "1 Pod", not "1 Pods".
-
-  const pod: SelectedKindInfo = { name: 'pods', kind: 'Pod', group: '' }
-
-  it('returns null when there is no active search', () => {
-    expect(sidebarHint({ Pod: 232 }, pod, '')).toBeNull()
-  })
-
-  it('returns null when the cluster total for the kind is 0', () => {
-    expect(sidebarHint({ Pod: 0 }, pod, 'xyz')).toBeNull()
-  })
-
-  it('returns null when the kind is missing from counts', () => {
-    expect(sidebarHint({}, pod, 'xyz')).toBeNull()
-  })
-
-  it('formats the sentence with the cluster total and pluralized kind', () => {
-    expect(sidebarHint({ Pod: 232 }, pod, 'xyz')).toBe(
-      'The sidebar shows 232 Pods in the cluster — the count is unfiltered.',
-    )
-  })
-
-  it('uses singular noun when total is 1', () => {
-    expect(sidebarHint({ Pod: 1 }, pod, 'xyz')).toBe(
-      'The sidebar shows 1 Pod in the cluster — the count is unfiltered.',
-    )
-  })
-
-  it('looks up grouped kinds under `${group}/${kind}`', () => {
-    const ar: SelectedKindInfo = { name: 'rollouts', kind: 'Rollout', group: 'argoproj.io' }
-    const counts = { Rollout: 999, 'argoproj.io/Rollout': 4 }
-    expect(sidebarHint(counts, ar, 'xyz')).toBe(
-      'The sidebar shows 4 Rollouts in the cluster — the count is unfiltered.',
-    )
-  })
-
-  it('pluralizes Ingress correctly (regression: not "Ingresss")', () => {
-    const ing: SelectedKindInfo = { name: 'ingresses', kind: 'Ingress', group: '' }
-    expect(sidebarHint({ Ingress: 3 }, ing, 'xyz')).toBe(
-      'The sidebar shows 3 Ingresses in the cluster — the count is unfiltered.',
-    )
-  })
-
-  it('pluralizes NetworkPolicy correctly (regression: not "NetworkPolicys")', () => {
-    const np: SelectedKindInfo = { name: 'networkpolicies', kind: 'NetworkPolicy', group: 'networking.k8s.io' }
-    expect(sidebarHint({ 'networking.k8s.io/NetworkPolicy': 2 }, np, 'xyz')).toBe(
-      'The sidebar shows 2 NetworkPolicies in the cluster — the count is unfiltered.',
-    )
-  })
-})