@skyhook-io/k8s-ui 1.8.10 → 1.8.11

package/src/utils/applications.test.ts

@@ -1,5 +1,47 @@
 import { describe, it, expect } from 'vitest'
-import { compareVersions, appGroupingExplainer, APP_IDENTITY_ANNOTATION, appGroupLagMessage, matchWorkloadAcrossInstances, foldAppGroups, identityEnvInferred, worstHealth, type AppGroupFoldEntry } from './applications'
+import { compareVersions, appGroupingExplainer, APP_IDENTITY_ANNOTATION, appGroupLagMessage, matchWorkloadAcrossInstances, foldAppGroups, identityEnvInferred, worstHealth, buildAppMembershipIndex, batchActivityForApp, batchRuntimeForApp, servingReadiness, type AppGroupFoldEntry, type AppRow, type AppWorkload } from './applications'
+
+describe('batch application runtime', () => {
+  it('uses the latest retained outcome instead of historical failure count', () => {
+    const app: AppRow = {
+      key: 'batch', name: 'batch', health: 'unhealthy', workload_class: 'job',
+      workloads: [{
+        kind: 'CronJob', namespace: 'demo', name: 'nightly', workload_class: 'job', health: 'unhealthy', ready: 0, desired: 0, restarts: 0,
+        batch: { retainedRuns: 4, failedRuns: 1, succeededRuns: 3, latestRunName: 'nightly-new', latestRunPhase: 'Succeeded', latestFinishedAt: '2026-07-10T00:00:00Z' },
+      }],
+    }
+    expect(batchRuntimeForApp(app)).toMatchObject({ label: 'Succeeded', health: 'healthy' })
+  })
+
+  it('does not let one workload success mask another workload latest failure', () => {
+    const app: AppRow = {
+      key: 'batch', name: 'batch', health: 'healthy', workload_class: 'job',
+      workloads: [
+        {
+          kind: 'CronJob', namespace: 'demo', name: 'nightly', workload_class: 'job', health: 'healthy', ready: 0, desired: 0, restarts: 0,
+          batch: { retainedRuns: 1, succeededRuns: 1, latestRunName: 'nightly-new', latestRunPhase: 'Succeeded', latestFinishedAt: '2026-07-10T01:00:00Z' },
+        },
+        {
+          kind: 'CronWorkflow', namespace: 'demo', name: 'sync', workload_class: 'job', health: 'unhealthy', ready: 0, desired: 0, restarts: 0,
+          batch: { retainedRuns: 1, failedRuns: 1, latestRunName: 'sync-old', latestRunPhase: 'Failed', latestFinishedAt: '2026-07-10T00:00:00Z' },
+        },
+      ],
+    }
+
+    expect(batchRuntimeForApp(app)).toEqual({
+      label: 'Failed',
+      health: 'unhealthy',
+      detail: 'CronWorkflow/sync latest retained run sync-old failed.',
+    })
+  })
+
+  it('excludes batch workloads from serving readiness', () => {
+    expect(servingReadiness([
+      { kind: 'Deployment', namespace: 'demo', name: 'api', workload_class: 'service', health: 'healthy', ready: 2, desired: 3, restarts: 0 },
+      { kind: 'Job', namespace: 'demo', name: 'run', workload_class: 'job', health: 'healthy', ready: 1, desired: 1, restarts: 0, batch: { retainedRuns: 1 } },
+    ])).toEqual({ ready: 2, desired: 3 })
+  })
+})
 
 describe('compareVersions', () => {
   it('orders semver', () => {
@@ -87,6 +129,46 @@ describe('identityEnvInferred', () => {
   })
 })
 
+describe('batchActivityForApp', () => {
+  const workload = (kind: string, name: string, batch?: AppWorkload['batch']): AppWorkload => ({
+    kind,
+    namespace: 'prod',
+    name,
+    health: 'neutral',
+    ready: 0,
+    desired: 0,
+    restarts: 0,
+    workload_class: kind === 'Deployment' ? 'service' : 'job',
+    batch,
+  })
+  const app = (workloads: AppWorkload[]): AppRow => ({
+    key: 'billing',
+    name: 'billing',
+    health: 'neutral',
+    workloads,
+  })
+
+  it('ranks failed, active, suspended, and quiet batch workloads without inventing retained history', () => {
+    const activity = batchActivityForApp(app([
+      workload('Deployment', 'api'),
+      workload('CronJob', 'nightly-success', { retainedRuns: 2, latestRunPhase: 'Succeeded', latestRunName: 'nightly-success-1' }),
+      workload('CronWorkflow', 'hourly-suspended', { suspended: true, retainedRuns: 0, schedule: '0 * * * *' }),
+      workload('Job', 'active-reindex', { activeRuns: 1, retainedRuns: 1, latestRunPhase: 'Running' }),
+      workload('Workflow', 'failed-migration', { failedRuns: 1, retainedRuns: 1, latestRunPhase: 'Failed', latestRunName: 'failed-migration', message: 'pod crashed' }),
+    ]))
+
+    expect(activity.map((item) => item.workload.name)).toEqual([
+      'failed-migration',
+      'active-reindex',
+      'hourly-suspended',
+      'nightly-success',
+    ])
+    expect(activity[0]).toMatchObject({ tone: 'rose', label: 'Latest run failed', failedRuns: 1, detail: 'pod crashed' })
+    expect(activity[1]).toMatchObject({ tone: 'sky', label: '1 active run', activeRuns: 1 })
+    expect(activity[3]).toMatchObject({ tone: 'muted', label: 'Latest run succeeded', retainedRuns: 2 })
+  })
+})
+
 // Position-preserving env switch: exact match, stem fallback (suffix, prefix,
 // discovered tokens), and the explicit no-counterpart null.
 describe('matchWorkloadAcrossInstances', () => {
@@ -296,3 +378,87 @@ describe('foldAppGroups pathKey disambiguation', () => {
     expect(rows.filter((r) => r.kind === 'instance').length).toBe(2)
   })
 })
+
+describe('buildAppMembershipIndex', () => {
+  // Minimal AppRow builder — only the fields the index reads.
+  const row = (over: Partial<AppRow>): AppRow => ({
+    key: 'k', name: 'app', health: 'healthy', workloads: [], ...over,
+  })
+
+  it('indexes workloads by Kind/ns/name and satellites by the app namespace', () => {
+    const idx = buildAppMembershipIndex([
+      row({
+        key: 'team-a/app/billing', name: 'billing', namespace: 'team-a',
+        workloads: [{ kind: 'Deployment', namespace: 'team-a', name: 'billing-api', health: 'healthy', ready: 1, desired: 1, restarts: 0 }],
+        relationships: { services: ['billing-svc'], ingresses: ['billing-ing'] },
+      }),
+    ])
+    expect(idx.byResource.get('Deployment/team-a/billing-api')?.appName).toBe('billing')
+    expect(idx.byResource.get('Service/team-a/billing-svc')?.appName).toBe('billing')
+    expect(idx.byResource.get('Ingress/team-a/billing-ing')?.appName).toBe('billing')
+  })
+
+  it('indexes routes under their concrete kind, not a generic "Route"', () => {
+    // The server ships "Kind/name" for polymorphic routes; the index must key on
+    // the concrete kind so it matches the route lane id (HTTPRoute/…/name).
+    const idx = buildAppMembershipIndex([
+      row({
+        key: 'team-a/app/web', name: 'web', namespace: 'team-a',
+        relationships: { routes: ['HTTPRoute/web-http', 'GRPCRoute/web-grpc'] },
+      }),
+    ])
+    expect(idx.byResource.get('HTTPRoute/team-a/web-http')?.appName).toBe('web')
+    expect(idx.byResource.get('GRPCRoute/team-a/web-grpc')?.appName).toBe('web')
+    expect(idx.byResource.has('Route/team-a/HTTPRoute/web-http')).toBe(false)
+  })
+
+  it('skips satellites for a multi-namespace app (can not place them unambiguously)', () => {
+    const idx = buildAppMembershipIndex([
+      row({
+        key: 'a', name: 'span', namespaces: ['team-a', 'team-b'],
+        workloads: [{ kind: 'Deployment', namespace: 'team-a', name: 'api', health: 'healthy', ready: 1, desired: 1, restarts: 0 }],
+        relationships: { services: ['svc'] },
+      }),
+    ])
+    expect(idx.byResource.has('Deployment/team-a/api')).toBe(true)
+    expect([...idx.byResource.keys()].some((k) => k.startsWith('Service/'))).toBe(false)
+  })
+
+  it('indexes matchKeys by evidence but excludes name-stem (exact kinds only in v1)', () => {
+    // matchKeys are namespace-scoped (kind:namespace:value); name-stem stays unscoped.
+    const idx = buildAppMembershipIndex([
+      row({ key: 'a', name: 'billing', identity: { key: 'billing', env: 'prod', confidence: 'high', evidence: 'x' }, matchKeys: ['instance:team-a:billing-prod', 'helm:team-a:billing-v2', 'name-stem:billing'] }),
+    ])
+    expect(idx.byEvidence.get('instance:team-a:billing-prod')?.appName).toBe('billing')
+    expect(idx.byEvidence.get('helm:team-a:billing-v2')?.appName).toBe('billing')
+    expect(idx.byEvidence.has('name-stem:billing')).toBe(false)
+  })
+
+  it('carries env + evidence onto the membership', () => {
+    const idx = buildAppMembershipIndex([
+      row({ key: 'a', name: 'billing', identity: { key: 'billing', env: 'prod', confidence: 'high', evidence: 'name stem billing' }, matchKeys: ['name:team-a:billing'] }),
+    ])
+    const m = idx.byEvidence.get('name:team-a:billing')
+    expect(m?.env).toBe('prod')
+    expect(m?.evidence).toBe('name stem billing')
+  })
+
+  it('collision resolves first-wins (server-sorted row order)', () => {
+    const idx = buildAppMembershipIndex([
+      row({ key: 'first', name: 'first', matchKeys: ['name:team-a:shared'] }),
+      row({ key: 'second', name: 'second', matchKeys: ['name:team-a:shared'] }),
+    ])
+    expect(idx.byEvidence.get('name:team-a:shared')?.appName).toBe('first')
+  })
+
+  it('same label value in two namespaces indexes as distinct evidence keys', () => {
+    // The whole point of namespace scoping: "shared" in team-a and team-b must
+    // NOT collapse to one key — each namespace maps to its own app.
+    const idx = buildAppMembershipIndex([
+      row({ key: 'a', name: 'app-a', matchKeys: ['instance:team-a:shared'] }),
+      row({ key: 'b', name: 'app-b', matchKeys: ['instance:team-b:shared'] }),
+    ])
+    expect(idx.byEvidence.get('instance:team-a:shared')?.appName).toBe('app-a')
+    expect(idx.byEvidence.get('instance:team-b:shared')?.appName).toBe('app-b')
+  })
+})